scon.c

用c写的ftp客户端源代码,可以在UNIX,Windows下编译通过,学习的好代码!

/* dftp: FTP client example
 * Copyright (c) 1996 by Donald C. Asonye
 * Email: [e-mail]
 *
 * scon.c.
 *
 * This and other files are hereby released	to the public for 
 * educational purposes.  You may redistribute this and other files
 * or routines as long as you are not compensated for it, and as 
 * long as this notice is included with it.  You may not use the 
 * released source codes in anyway commercial without permission.
 *
 * It'd be nice if you share your modifications with me and everyone
 * else.  I encourage you to make the code better as I am very busy.
 *
 * Share your knowledge :)
 */

#include "scon.h"

#include "extfuncs.h"


extern char szBuffer[];

extern int ReadCommand;



int GetListenSocket()

{

    int sockfd, flag=1,len;

    struct sockaddr_in  serv_addr, TempAddr;

    char *port,*ipaddr;

    char szBuffer[64]={0};



    /*

     * Open a TCP socket (an Internet stream socket).

     */

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

	perror("socket");

	return INVALID_SOCKET;

    }



    /*

     * Fill in structure fields for binding

     */

   if( bSendPort ) {

       bzero((char *) &serv_addr, sizeof(serv_addr));

       serv_addr.sin_family      = AF_INET;

       serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

       serv_addr.sin_port        = htons(0); /* let system choose */

   }

   else {

     /* reuse the control socket then */

      if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,

         (char *)&flag,sizeof(flag)) < 0) {



	 perror("setsockopt");

#if (!defined( _WIN32 ) || !defined( WIN32 ))

	 close(sockfd);

#else

         closesocket(sockfd);

#endif

	 return INVALID_SOCKET;



      }

   }

    /*

     * bind the address to the socket

     */

    if (bind(sockfd,(struct sockaddr *)&serv_addr, 

	     sizeof(serv_addr)) < 0) {

	perror("bind");

#if (!defined( _WIN32 ) || !defined( WIN32 ))

	close(sockfd);

#else

        closesocket(sockfd);

#endif

	return INVALID_SOCKET;

    }

    

    len = sizeof(serv_addr);

    if(getsockname(sockfd,

		   (struct sockaddr *)&serv_addr,

		   &len)<0) {

       perror("getsockname");

#if (!defined( _WIN32 ) || !defined( WIN32 ))

	close(sockfd);

#else

        closesocket(sockfd);

#endif

       return INVALID_SOCKET;

    }

    len = sizeof(TempAddr);

    if(getsockname(hControlSocket,

		   (struct sockaddr *)&TempAddr,

		   &len)<0) {

       perror("getsockname");

#if (!defined( _WIN32 ) || !defined( WIN32 ))

	close(sockfd);

#else

        closesocket(sockfd);

#endif

       return INVALID_SOCKET;

    }



    ipaddr = (char *)&TempAddr.sin_addr;

    port  = (char *)&serv_addr.sin_port;



#define  UC(b)  (((int)b)&0xff)



    sprintf(szBuffer,"PORT %d,%d,%d,%d,%d,%d\r\n",

          UC(ipaddr[0]), UC(ipaddr[1]), UC(ipaddr[2]), UC(ipaddr[3]),

          UC(port[0]), UC(port[1]));

    /*

     * allow ftp server to connect

     * allow only one server

     */

    if( listen(sockfd, 1) < 0) {

	perror("listen");

#if (!defined( _WIN32 ) || !defined( WIN32 )) 

	close(sockfd);

#else

        closesocket(sockfd);

#endif

	return INVALID_SOCKET;

    }

    SendControlMsg(szBuffer,strlen(szBuffer));

    GetReply();

    hListenSocket = sockfd;

    return sockfd;

}



int AcceptConnection()

{



    struct sockaddr_in cli_addr;

    int clilen = sizeof(cli_addr);

    int sockfd;



    sockfd = accept(hListenSocket, (struct sockaddr *) &cli_addr,

			   &clilen);

    if (sockfd < 0) {

        perror("accept");

	return INVALID_SOCKET;

    }

   

    hDataSocket = sockfd;

#if (!defined( _WIN32 ) || !defined( WIN32 )) 

    close(hListenSocket);

#else

    closesocket(hListenSocket);

#endif

    return sockfd;



}





int ConnectToServer(char *name, char *port)



{

  int s;
  unsigned int portnum;



  struct sockaddr_in server;

  struct hostent *hp;



  while( name && *name == ' ') name++;

  if( !name || ! (*name) )

      return INVALID_SOCKET;



  portnum = atoi(port);

  bzero((char *) &server, sizeof(server));



  if( isdigit(name[0])) {

   server.sin_family      = AF_INET;

   server.sin_addr.s_addr = inet_addr(name);

   server.sin_port        = htons(portnum);

  }

  else{ 

   if ( (hp = gethostbyname(name)) == NULL)

    {
#if (!defined( _WIN32 ) || !defined( WIN32 ))

      perror("gethostbyname");
#else 
	  printf("gethostbyname: error code: %d\r\n", WSAGetLastError());

#endif
	  return INVALID_SOCKET;

    }

    bcopy(hp->h_addr,(char *) &server.sin_addr,hp->h_length);

    server.sin_family = hp->h_addrtype;

    server.sin_port = htons(portnum);  

   }/* else */



  /* create socket */

  if( (s = socket(AF_INET, SOCK_STREAM, 0)) < 1) {
#if (!defined( _WIN32 ) || !defined( WIN32 ))
	  perror("socket");
#else
	  printf("socket: error code: %d\r\n", WSAGetLastError());
#endif

    return INVALID_SOCKET;

  }

  

  if (connect(s,(struct sockaddr *)&server, sizeof(server))< 0) {

#if (!defined( _WIN32 ) || !defined( WIN32 ))
	  perror("connect");
#else
	  printf("connect: error code: %d\r\n", WSAGetLastError());
#endif    
	  

    return INVALID_SOCKET;

  }

  

  setsockopt(s,SOL_SOCKET,SO_LINGER,0,0);

  setsockopt(s,SOL_SOCKET,SO_REUSEADDR,0,0);

  setsockopt(s,SOL_SOCKET,SO_KEEPALIVE,0,0);

  hDataSocket = s;

  

  return s;

}



int ReadControlMsg( char *szBuffer, int len)

{

  int ret;

   

   if( (ret=recv(hControlSocket,szBuffer,len,0)) <= 0)

       return 0;

   

   return ret;

}



int SendControlMsg( char *szBuffer, int len)

{

   

   if( send(hControlSocket,szBuffer,len,0) <= 0)

       return 0;

   

   return 1;

}



int ReadDataMsg( char *szBuffer, int len)

{

   int ret;



   if( (ret=recv(hDataSocket,szBuffer,len,0)) <= 0)

       return 0;

   

   return ret;

}



int SendDataMsg( char *szBuffer, int len)

{

   

   if( send(hDataSocket,szBuffer,len,0) <= 0)

       return 0;

   

   return 1;

}



void CloseDataConnection( void )

{

#if (!defined( _WIN32 ) || !defined( WIN32 )) 

      close(hDataSocket);

#else

      closesocket(hDataSocket);

#endif



      hDataSocket = INVALID_SOCKET;

}



void CloseControlConnection( void )

{

#if (!defined( _WIN32 ) || !defined( WIN32 )) 

      close(hControlSocket);

#else

      closesocket(hControlSocket);

#endif



      hControlSocket = INVALID_SOCKET;

}


void CloseListenSocket( void )
{
#if (!defined( _WIN32 ) || !defined( WIN32 )) 
      close(hListenSocket);
#else
      closesocket(hListenSocket);
#endif

      hListenSocket = INVALID_SOCKET;
}


int CheckControlMsg( char *szPtr, int len)

{

    

    return recv(hControlSocket,szPtr,len,MSG_PEEK);

}







int GetLine()

{

   int done=0, iRetCode =0, iLen, iBuffLen=0;

   char *szPtr = szBuffer, nCode[3]={0},ch=0;



   while( (iBuffLen < 1024) && 

	  (CheckControlMsg(&ch,1)  > 0) ){

        iLen = ReadControlMsg(&ch,1);

	iBuffLen += iLen;

	*szPtr = ch;

	szPtr += iLen;

	if( ch == '\n' )

	    break;    // we have a line: return

   }

   *(szPtr+1) = (char)0;



   strncpy(nCode, szBuffer, 3);



   return (atoi(nCode));



}



int GetReply()

{

   int done = 0, iRetCode = 0;

     

   memset(szBuffer,0,1024);

   while(!done ) {

        iRetCode = GetLine();

	(void)strtok(szBuffer,"\r\n");

	puts(szBuffer);

	if( szBuffer[3] != '-' && iRetCode > 0 )

	    done = 1;

	memset(szBuffer,0,1024);

   }

   return iRetCode;

}



int CheckInput()
{
  int rval, i;
 fd_set readfds, writefds, exceptfds;
 struct timeval timeout;



#if (!defined(WIN32) || !defined(_WIN32) )
  FD_ZERO(&readfds);
  FD_ZERO(&writefds);
  FD_ZERO(&exceptfds);
  FD_CLR (fileno(stdin),&readfds);

  timeout.tv_sec = 0 ;                /* 0-second timeout. */
  timeout.tv_usec = 0 ;               /* 0 microseconds.  */
  FD_SET(fileno(stdin),&readfds);

  i=select ( fileno(stdin)+1,
	         &readfds,
			 &writefds,
			 &exceptfds,
			 &timeout);
 /* SELECT interrupted by signal - try again.  */

  if (errno == EINTR && i ==-1)  {
 	  return 0;

  }
  return ( FD_ISSET(fileno(stdin),&readfds) );
#else
	   return (kbhit() );
#endif

}

int  CheckFds( char *command)
{
 int rval, i;
 fd_set readfds, writefds, exceptfds;
 struct timeval timeout;
 char *szInput=command;


/*  memset(command,0,1024); */
  memset(szBuffer,0,1024);
  FD_ZERO(&readfds);
  FD_ZERO(&writefds);
  FD_ZERO(&exceptfds);
#if (!defined(WIN32) || !defined(_WIN32) )
  FD_CLR (fileno(stdin),&readfds);
#endif
  if( hControlSocket > 0) 
      FD_CLR (hControlSocket,&readfds);
  timeout.tv_sec = 0 ;                /* 1-second timeout. */
  timeout.tv_usec = 0 ;               /* 0 microseconds.  */

#if (!defined( _WIN32 ) || !defined( WIN32 ) )
  FD_SET(fileno(stdin),&readfds);
#endif

  if( hControlSocket > 0) 
      FD_SET(hControlSocket,&readfds);

  i=select ((hControlSocket > 0) ? (hControlSocket+1) : 1,
	         &readfds,
			 &writefds,
			 &exceptfds,
			 &timeout);
 /* SELECT interrupted by signal - try again.  */
if (errno == EINTR && i ==-1)  {
   /*memset(command,0,1024);*/
   return 0;
}


if( (hControlSocket > 0) && FD_ISSET(hControlSocket, &readfds) ) 
{
  if ( ( rval = ReadControlMsg(szBuffer,1024))  > 0)
	  {
	  printf(szBuffer);
	  printf("ftp>");
	  fflush(stdout);
	  return 0;
	  }
  else {
	 printf("\r\nConnection closed by server\r\n");
#if (defined(WIN32) || defined(_WIN32) )

	 SetConsoleTitle("dftp: Connection closed");
#endif
	 
	 CloseControlConnection();
	 hControlSocket = -1;
	 return 0;
  }

 }

#if (!defined( _WIN32 ) || !defined( WIN32 ) )

   if( FD_ISSET(fileno(stdin),&readfds) )  
       return (ReadCommand = GetUnixInput(command));
   return (ReadCommand = 0);
#else
    
   return (ReadCommand = GetWin32Input(command));

#endif

}

#if (defined( WIN32) || defined(_WIN32) )
int InitWinsock()
{

	WSADATA WsaData;

	if( !WSAStartup(0x0101,&WsaData) ) {
		SetConsoleTitle("dftp: Connection closed");
		return 1;
	}
	else {
	 printf("Winsock cannot be started\r\n");
	 return 0;
	}
	
}

void CleanUp()
{

	WSACleanup();
}
#endif