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

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

Ftp客户端

开发平台：

Unix_Linux

ls.c：源码内容
  1. /* $Id: ls.c,v 1.10 1999/02/13 15:23:42 agulbra Exp $ */
  3. #include <time.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  7. #include <ctype.h>
  8. #include <sys/time.h>
  9. #include <setjmp.h>
  10. #include <errno.h>
  11. #include <string.h>
  12. #include <syslog.h>
  13. #include <sys/types.h>
  14. #include <sys/socket.h>
  15. #include <netinet/in.h>
  16. #include <sys/stat.h>
  17. #include <fcntl.h>
  18. #include <sys/mman.h>
  19. #include <sys/param.h>
  20. #include <pwd.h>
  21. #include <grp.h>
  22. #include <arpa/inet.h>
  23. #include <netdb.h>
  24. #ifndef _GNU_SOURCE
  25. #define _GNU_SOURCE /* for GLOB_ABEND in newer glibcs */
  26. #endif
  27. #include <glob.h> /* linux rules! */
  28. #include <dirent.h>
  29. #include <sys/resource.h>
  30. #include <sys/vfs.h>
  31. #include <signal.h>
  33. #include "ftpd.h"
  35. #if defined(GLOB_ABORTED) && !defined(GLOB_ABEND)
  36. #define GLOB_ABEND GLOB_ABORTED
  37. #endif
  39. static char *getname( const uid_t uid );
  41. static char **sreaddir( const char *dirname );
  43. static void addfile( const char *, const char * );
  44. static void outputfiles( int );
  46. static int listfile( const char *name );
  47. static void listdir( int f, const char *name );
  49. char *users = NULL;
  50. char *groups = NULL;
  52. static int matches;
  54. static char outbuf[1024];
  55. static int outptr = 0;
  57. static void wrstr( int f, const char * s )
  58. {
  59.     int l;
  61.     if ( !s ) {
  62. if ( outptr )
  63.     write( f, outbuf, outptr );
  64. outptr = 0;
  65. return;
  66.     }
  68.     l = strlen( s );
  69.     if ( l + outptr > 1024 ) {
  70. if ( outptr )
  71.     write( f, outbuf, outptr );
  72. outptr = 0;
  73.     }
  75.     if ( l > 1024 ) {
  76. write( f, s, l );
  77.     } else {
  78. memcpy( outbuf+outptr, s, l );
  79. outptr += l;
  80.     }
  81. }
  85. void getnames( void )
  86. {
  87.     int f;
  89.     /* uid_t can have 65536 values on linux */
  91.     f = open( "/var/adm/ftp/users", O_RDONLY );
  92.     if ( f >= 0 ) {
  93. users = mmap( 0, (size_t) 9 * 65536,
  94.       PROT_READ, MAP_FILE | MAP_SHARED, f, 0 );
  95. if ( users == (void *) -1 ) {
  96.     users = NULL;
  97.     close( f );
  98. }
  99.     }
  100.     f = open( "/var/adm/ftp/groups", O_RDONLY );
  101.     if ( f >= 0 ) {
  102. groups = mmap( 0, ( size_t ) 9 * 65536,
  103.        PROT_READ, MAP_FILE | MAP_SHARED, f, 0 );
  104. if ( groups == (void *)-1 ) {
  105.     groups = NULL;
  106.     close( f );
  107. }
  108.     }
  109. }
  112. char *getname( const uid_t uid )
  113. {
  114.     static char number[9];
  116.     if ( users && users[9 * uid] ) {
  117. return ( users + ( 9 * uid ) );
  118.     } else {
  119. sprintf( number, "%-8d", uid );
  120. return ( number );
  121.     }
  122. }
  125. char *getgroup( const gid_t gid )
  126. {
  127.     static char number[9];
  129.     if ( groups && groups[9 * gid] ) {
  130. return ( groups + ( 9 * gid ) );
  131.     } else {
  132. sprintf( number, "%-8d", gid );
  133. return ( number );
  134.     }
  135. }
  138. /* ls options */
  139. int opt_a,
  140.   opt_C,
  141.   opt_d,
  142.   opt_F,
  143.   opt_l,
  144.   opt_R,
  145.   opt_r,
  146.   opt_t,
  147.   opt_S;
  150. /* listfile returns non-zero if the file is a directory */
  151. int listfile( const char *name )
  152. {
  153.     int rval = 0;
  154.     char m[1024];
  155.     struct stat st;
  156.     char months[12][4] =
  157.     {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  158.      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  159.     struct tm *t;
  160.     char suffix[2];
  162.     if ( lstat( name, &st ) == 0 ) {
  163. t = localtime( (time_t * ) & st.st_mtime );
  164. if ( !t ) {
  165.     printf( "421 Bailing out, localtime() is insanern" );
  166.     fflush( stdout );
  167.     exit( 2 );
  168. }
  169. suffix[0] = suffix[1] = '';
  170. if ( opt_F ) {
  171.     if ( S_ISLNK( st.st_mode ) )
  172. suffix[0] = '@';
  173.     else if ( S_ISDIR( st.st_mode ) ) {
  174. suffix[0] = '/';
  175. rval = 1;
  176.     } else if ( st.st_mode & 010101 )
  177. suffix[0] = '*';
  178. }
  179. if ( opt_l ) {
  180.     strcpy( m, " ---------" );
  181.     switch ( st.st_mode & S_IFMT ) {
  182. case S_IFREG:
  183. m[0] = '-';
  184. break;
  185. case S_IFLNK:
  186. m[0] = 'l';
  187. break; /* readlink() here? */
  188. case S_IFDIR:
  189. m[0] = 'd';
  190. rval = 1;
  191. break;
  192.     }
  193.     if ( m[0] != ' ' ) {
  194. char nameline[PATH_MAX + PATH_MAX + 128];
  195. char timeline[6];
  197. if ( st.st_mode & 256 )
  198.     m[1] = 'r';
  199. if ( st.st_mode & 128 )
  200.     m[2] = 'w';
  201. if ( st.st_mode & 64 )
  202.     m[3] = 'x';
  203. if ( st.st_mode & 32 )
  204.     m[4] = 'r';
  205. if ( st.st_mode & 16 )
  206.     m[5] = 'w';
  207. if ( st.st_mode & 8 )
  208.     m[6] = 'x';
  209. if ( st.st_mode & 4 )
  210.     m[7] = 'r';
  211. if ( st.st_mode & 2 )
  212.     m[8] = 'w';
  213. if ( st.st_mode & 1 )
  214.     m[9] = 'x';
  216. if ( time( NULL ) - st.st_mtime > 180 * 24 * 60 * 60 )
  217.     sprintf( timeline, "%5d", t->tm_year + 1900 );
  218. else
  219.     sprintf( timeline, "%02d:%02d", t->tm_hour, t->tm_min );
  221. sprintf( nameline, "%s %3d %s %s %7d %s %2d %s %s", m,
  222.     st.st_nlink, getname( st.st_uid ), getgroup( st.st_gid ),
  223. ( unsigned int ) st.st_size, months[t->tm_mon],
  224. t->tm_mday, timeline, name );
  225. if ( S_ISLNK( st.st_mode ) ) {
  226.     char *p = nameline + strlen( nameline );
  228.     m[readlink( name, m, 1023 )] = '';
  229.     suffix[0] = '';
  230.     if ( opt_F && stat( name, &st ) == 0 ) {
  231. if ( S_ISLNK( st.st_mode ) )
  232.     suffix[0] = '@';
  233. else if ( S_ISDIR( st.st_mode ) )
  234.     suffix[0] = '/';
  235. else if ( st.st_mode & 010101 )
  236.     suffix[0] = '*';
  237.     }
  238.     sprintf( p, " -> %s", m );
  239. }
  240. addfile( nameline, suffix );
  241.     } /* hide non-downloadable files */
  242. } else {
  243.     if ( S_ISREG( st.st_mode ) ||
  244. S_ISDIR( st.st_mode ) ||
  245. S_ISLNK( st.st_mode ) ) {
  246. addfile( name, suffix );
  247.     }
  248. }
  249.     }
  250.     return rval;
  251. }
  254. int colwidth = 0;
  255. int filenames = 0;
  257. struct filename {
  258.     struct filename *down;
  259.     struct filename *right;
  260.     int top;
  261.     char line[1];
  262. };
  265. struct filename *head = NULL;
  266. struct filename *tail = NULL;
  269. void addfile( const char *name, const char *suffix )
  270. {
  271.     struct filename *p;
  272.     int l;
  274.     if ( !name || !suffix )
  275. return;
  277.     matches++;
  279.     l = strlen( name ) + strlen( suffix );
  280.     if ( l > colwidth )
  281. colwidth = l;
  283.     p = ( struct filename * ) malloc( sizeof( struct filename ) + l );
  285.     if ( !p ) {
  286. printf( "421 Out of memoryrn" );
  287. fflush( stdout );
  288. exit( 7 );
  289.     }
  290.     sprintf( p->line, "%s%s", name, suffix );
  291.     if ( tail )
  292. tail->down = p;
  293.     else
  294. head = p;
  295.     tail = p;
  296.     filenames++;
  297. }
  300. void outputfiles( int f )
  301. {
  302.     int n;
  303.     struct filename *p;
  304.     struct filename *q;
  306.     if ( !head )
  307. return;
  309.     tail->down = NULL;
  310.     tail = NULL;
  311.     colwidth = ( colwidth | 7 ) + 1;
  312.     if ( opt_l || !opt_C )
  313. colwidth = 75;
  315.     /* set up first column */
  316.     p = head;
  317.     p->top = 1;
  318.     n = (filenames + (75 / colwidth)-1) / (75 / colwidth);
  319.     while ( n && p ) {
  320. p = p->down;
  321. if ( p )
  322.     p->top = 0;
  323. n--;
  324.     }
  326.     /* while there's a neighbour to the right, point at it */
  327.     q = head;
  328.     while ( p ) {
  329. p->top = q->top;
  330. q->right = p;
  331. q = q->down;
  332. p = p->down;
  333.     }
  335.     /* some are at the right end */
  336.     while ( q ) {
  337. q->right = NULL;
  338. q = q->down;
  339.     }
  341.     /* don't want wraparound, do we? */
  342.     p = head;
  343.     while ( p && p->down && !p->down->top )
  344. p = p->down;
  345.     if ( p && p->down )
  346. p->down = NULL;
  348.     /* print each line, which consists of each column */
  349.     p = head;
  350.     while ( p ) {
  351. q = p;
  352. p = p->down;
  353. while ( q ) {
  354.     char pad[6];
  355.     char *tmp = ( char * ) q;
  357.     if ( q->right ) {
  358. strcpy( pad, "ttttt" );
  359. pad[( colwidth + 7 - strlen( q->line ) ) / 8] = '';
  360.     } else {
  361. strcpy( pad, "rn" );
  362.     }
  363.     wrstr( f, q->line );
  364.     wrstr( f, pad );
  365.     q = q->right;
  366.     free( tmp );
  367. }
  368.     }
  370.     /* reset variables for next time */
  371.     head = tail = NULL;
  372.     colwidth = 0;
  373.     filenames = 0;
  374. }
  378. char **sreaddir( const char *dirname )
  379. {
  380.     DIR *d;
  381.     struct dirent *de;
  382.     struct stat st;
  383.     int i;
  384.     char **p;
  385.     int s;
  386.     int dsize;
  387.     static int cmp( const void *a, const void *b );
  389.     /* functions to to sort for qsort() */
  390.     static int cmp( const void *a, const void *b ) {
  391. return strcmp( *( const char ** ) a, *( const char ** ) b );
  392.     }
  393.     static int cmp_r ( const void *a, const void *b ) {
  394. return strcmp( *( const char ** ) b, *( const char ** ) a );
  395.     }
  396.     static int cmp_t ( const void *a, const void *b ) {
  397.         return *(*(const int **)a -2) - *(*(const int **)b -2);
  398.     }
  399.     static int cmp_rt ( const void *a, const void *b ) {
  400.         return *(*(const int **)b -2) - *(*(const int **)a -2);
  401.     }
  402.     static int cmp_S ( const void *a, const void *b ) {
  403.         return *(*(const int **)b -1) - *(*(const int **)a -1);
  404.     }
  405.     static int cmp_rS ( const void *a, const void *b ) {
  406.         return *(*(const int **)a -1) - *(*(const int **)b -1);
  407.     }
  409.     if ( stat( dirname, &st ) < 0 )
  410. return NULL;
  412.     if ( !S_ISDIR( st.st_mode ) ) {
  413. errno = ENOTDIR;
  414. return NULL;
  415.     }
  416.     if ( (d = opendir( dirname ) ) == NULL )
  417. return NULL;
  419.     /* st_size is enough for any sane fs, but procfs is insane */
  420.     dsize = st.st_size + 100; /* okay okay, a little margin is cool */
  422.  berkeley:
  423.     dsize = dsize * 2;
  424.     p = (char **)malloc( dsize );
  426.     if ( !p ) {
  427. closedir( d );
  428. errno = ENOMEM;
  429. return NULL;
  430.     }
  431.     s = dsize;
  432.     i = 0;
  434.     while ( (de = readdir( d ) ) != NULL ) {
  435. struct stat st;
  436. if ( s < i*sizeof(int) + 3*sizeof(int) + strlen( de->d_name ) + 1 ) {
  437.     /* should leak some memory too, make it perfect : ) */
  438.     free( p );
  439.     rewinddir( d );
  440.     goto berkeley;
  441. }
  442. s -= strlen( de->d_name ) + 1;
  443. strcpy( ((char *)p)+s, de->d_name );
  444. p[i++] = ((char *)p)+s;
  445. if (!lstat(de->d_name,&st)) {
  446.     s -= sizeof(int);
  447.     *((int *)(((char *)p) + s))=st.st_size;
  448.     s -= sizeof(int);
  449.     *((int *)(((char *)p) + s))=st.st_size;
  450. } else {
  451.     s -= sizeof(int);
  452.     *((int *)(((char *)p) + s))=0;
  453.     s -= sizeof(int);
  454.     *((int *)(((char *)p) + s))=0;
  455. }
  456.     }
  457.     closedir( d );
  458.     p[i] = NULL;
  460.     if (opt_t)
  461. if (opt_r)
  462.     qsort( p, i, sizeof( char * ), cmp_rt );
  463. else
  464.     qsort( p, i, sizeof( char * ), cmp_t );
  465.     else if (opt_S)
  466. if (opt_r)
  467.     qsort( p, i, sizeof( char * ), cmp_rS );
  468. else
  469.     qsort( p, i, sizeof( char * ), cmp_S );
  470.     else
  471. if (opt_r)
  472.     qsort( p, i, sizeof( char * ), cmp_r );
  473. else
  474.     qsort( p, i, sizeof( char * ), cmp );
  476.     return p;
  477. }
  479. /* have to change to the directory first ( speed hack for -R ) */
  480. void listdir( int f, const char *name )
  481. {
  482.     char **dir;
  484.     dir = sreaddir( "." );
  485.     if ( dir ) {
  486. char **s;
  487. char **r;
  488. int d;
  490. wrstr( f, "total 1rn" ); /* so what is total anyway */
  491. s = dir;
  492. while ( *s ) {
  493.     if ( **s != '.' ) {
  494. d = listfile( *s );
  495.     } else if ( opt_a ) {
  496. d = listfile( *s );
  497. if ( ( (*s)[1] == '' ) ||
  498.      ( ( (*s)[1] == '.' ) &&
  499.        ( (*s)[2] == '' ) ) )
  500.     d = 0;
  501.     } else {
  502. d = 0;
  503.     }
  504.     if ( !d )
  505. *s = NULL;
  506.     s++;
  507. }
  508. outputfiles( f );
  509. r = dir;
  510. while ( opt_R && r != s ) {
  511.     if ( *r && !chdir( *r ) ) {
  512. char subdir[MAXPATHLEN];
  514. sprintf( subdir, "%s/%s", name, *r );
  515. wrstr( f, "rn" );
  516. wrstr( f, subdir );
  517. wrstr( f, ":rn" );
  518. listdir( f, subdir );
  519. if ( chdir( ".." ) ) { /* defensive in the extreme... */
  520.     chdir( wd );
  521.     if ( chdir( name ) ) { /* someone rmdir()'d it? */
  522. printf( "421 Unrecoverable file system error: %srn",
  523. strerror( errno ) );
  524. fflush( stdout );
  525. exit( 13 );
  526.     }
  527. }
  528.     }
  529.     r++;
  530. }
  531. free( dir );
  532.     } else {
  533. addreply( 226, "Out of memory during reading of %s", name );
  534.     }
  535. }
  538. void donlist( char *arg )
  539. {
  540.     int c;
  542.     matches = 0;
  544.     opt_a = opt_C = opt_d = opt_F = opt_R = opt_r = opt_t = opt_S = 0;
  546.     while ( isspace( *arg ) )
  547. arg++;
  549.     while ( arg && *arg == '-' ) {
  550. while ( arg++ && isalnum( *arg ) ) {
  551.     switch ( *arg ) {
  552.     case 'a':
  553. opt_a = 1;
  554. break;
  555.     case 'l':
  556. opt_l = 1;
  557. opt_C = 0;
  558. break;
  559.     case '1':
  560. opt_l = opt_C = 0;
  561. break;
  562.     case 'C':
  563. opt_l = 0;
  564. opt_C = 1;
  565. break;
  566.     case 'F':
  567. opt_F = 1;
  568. break;
  569.     case 'R':
  570. opt_R = 1;
  571. break;
  572.     case 'd':
  573. opt_d = 1;
  574. break;
  575.     case 'r':
  576. opt_r = 1;
  577. break;
  578.     case 't':
  579. opt_t = 1;
  580. opt_S = 0;
  581. break;
  582.     case 'S':
  583. opt_S = 1;
  584. opt_t = 0;
  585. break;
  586.     default:
  588.     }
  589. }
  590. while ( isspace( *arg ) )
  591.     arg++;
  592.     }
  594.     c = opendata();
  595.     if ( !c )
  596. return;
  598.     doreply();
  600.     if ( type == 2 )
  601. addreply( 0, "Binary mode requested, but A (ASCII) used." );
  603.     if ( arg && *arg ) {
  604. int justone;
  605. char * doshack;
  607. justone = 1; /* just one argument, so don't print dir name */
  609. while ( arg ) {
  610.     glob_t g;
  611.     int a;
  612.     char buffer[PATH_MAX];
  614.     char *endarg = strchr( arg, ' ' );
  616.     if ( endarg ) {
  617. *endarg++ = '';
  618. justone = 0;
  619.     }
  621.     if ( debug )
  622. addreply( 226, "Glob argument: %s", arg );
  624.     if ( loggedin && !guest && *arg == '~' ) {
  625. struct passwd *pw;
  626. int i;
  627. const char *p;
  629. i = 0;
  630. p = arg;
  631. p++;
  632. while ( *p && *p != '/' )
  633.     buffer[i++] = *p++;
  634. buffer[i] = '';
  636. if ( (pw = getpwnam( i ? buffer : account ) ) )
  637.     sprintf( buffer, "%s%s", pw->pw_dir, p );
  638. else
  639.     *buffer = '';
  640.     } else {
  641. *buffer = '';
  642.     }
  644.     /* try to defend against wildcard denial-of-service attack */
  645.     doshack = strstr( arg, "/../" );
  646.     if ( doshack ) {
  647. /* first eliminate those at the start */
  648. if ( doshack == arg ) {
  649.     while( strncmp( arg, "/../", 4 ) == 0 )
  650. strcpy( arg, arg+4 );
  651.     doshack = strstr( arg, "/../" );
  652. }
  653. /* next, eliminate /../ in the middle of the string */
  654. while( doshack ) {
  655.     char * nextcomponent = doshack + 4;
  656.     if ( doshack != arg && *doshack == '/' )
  657. doshack--;
  658.     while( doshack != arg && *doshack != '/' )
  659. doshack--;
  660.     if ( *doshack == '/' )
  661. doshack++;
  662.     strcpy( doshack, nextcomponent );
  663.     doshack = strstr( arg, "/../" );
  664. }
  665. addreply( 0, "Simplified wildcard expression to %s", arg );
  666.     }
  668.     a = glob( *buffer ? buffer:arg, opt_a ? GLOB_PERIOD : 0,
  669.       NULL, &g );
  670.     if ( !a ) {
  671. char **path;
  673. path = g.gl_pathv;
  674. if ( path && path[0] && path[1] )
  675.     justone = 0;
  677. while ( path && *path ) {
  678.     struct stat st;
  680.     if ( lstat( *path, &st ) == 0 ) {
  681. if ( opt_d || !( S_ISDIR( st.st_mode ) ) ) {
  682.     listfile( *path );
  683.     **path = '';
  684. }
  685.     } else {
  686. **path = '';
  687.     }
  688.     path++;
  689. }
  690. outputfiles( c ); /* in case of opt_C */
  691. path = g.gl_pathv;
  692. while ( path && *path ) {
  693.     if ( **path ) {
  694. if ( !justone ) {
  695.     wrstr( c, "rr" );
  696.     wrstr( c, *path );
  697.     wrstr( c, ":rn" );
  698. }
  699. if ( !chdir( *path ) ) {
  700.     listdir( c, *path );
  701.     chdir( wd );
  702. }
  703.     }
  704.     path++;
  705. }
  706.     } else {
  707. if ( a == GLOB_NOSPACE ) {
  708.     addreply( 226,
  709.       "Out of memory during globbing of %s", arg );
  710.     addreply( 0,
  711.       "(This probably means "Permission denied")" );
  712. } else if ( a == GLOB_ABEND ) {
  713.     addreply( 226,
  714.       "Read error during globbing of %s", arg );
  715. } else if ( a != GLOB_NOMATCH ) {
  716.     addreply( 226,
  717.       "Unknown error during globbing of %s", arg );
  718. }
  719.     }
  720.     globfree( &g );
  721.     arg = endarg;
  722. }
  723.     } else {
  724. if ( opt_d )
  725.     listfile( "." );
  726. else
  727.     listdir( c, "." );
  728. outputfiles( c );
  729.     }
  730.     wrstr( c, NULL );
  731.     close( c );
  732.     if ( opt_a || opt_C || opt_d || opt_F || opt_l || opt_r || opt_R ||
  733.  opt_t || opt_S )
  734. addreply( 0, "Options: %s%s%s%s%s%s%s%s%s",
  735.   opt_a ? "-a " : "",
  736.   opt_C ? "-C " : "",
  737.   opt_d ? "-d " : "",
  738.   opt_F ? "-F " : "",
  739.   opt_l ? "-l " : "",
  740.   opt_r ? "-r " : "",
  741.   opt_R ? "-R " : "",
  742.   opt_S ? "-S " : "",
  743.   opt_t ? "-t" : "" );
  744.     addreply( 226, "%d matches total", matches );
  745. }