int RASocket::authenticate()
{
    if (send(std::string("Username: ")) == -1)
        return -1;

    std::string user;
    if (recv_line(user) == -1)
        return -1;

    if (send(std::string("Password: ")) == -1)
        return -1;

    std::string pass;
    if (recv_line(pass) == -1)
        return -1;

    sLog->outRemote("Login attempt for user: %s", user.c_str());

    if (check_access_level(user) == -1)
        return -1;

    if (check_password(user, pass) == -1)
        return -1;

    sLog->outRemote("User login: %s", user.c_str());

    return 0;
}

int RASocket::svc(void)
{
    if (send("Authentication required\r\n") == -1)
        return -1;

    if (authenticate() == -1)
    {
        (void) send("Authentication failed\r\n");
        return -1;
    }

    // send motd
    if (send(std::string(sWorld->GetMotd()) + "\r\n") == -1)
        return -1;

    for(;;)
    {
        // show prompt
        const char* tc_prompt = "TC> ";
        if (size_t(peer().send(tc_prompt, strlen(tc_prompt))) != strlen(tc_prompt))
            return -1;

        std::string line;

        if (recv_line(line) == -1)
            return -1;

        if (process_command(line) == -1)
            return -1;
    }

    return 0;
}

int RASocket::svc(void)
{
    //! Subnegotiation may differ per client - do not react on it
    subnegotiate();

    if (send("Authentication required\r\n") == -1)
        return -1;

    if (authenticate() == -1)
    {
        (void) send("Authentication failed\r\n");
        return -1;
    }

    // send motd
    if (send(std::string(sWorld->GetMotd()) + "\r\n") == -1)
        return -1;

    for (;;)
    {
        // show prompt
        if (send("TC> ") == -1)
            return -1;

        std::string line;

        if (recv_line(line) == -1)
            return -1;

        if (process_command(line) == -1)
            return -1;
    }

    return 0;
}

int RASocket::recv_line(std::string& out_line)
{
    char buf[4096];

    ACE_Data_Block db(sizeof (buf),
            ACE_Message_Block::MB_DATA,
            buf,
            0,
            0,
            ACE_Message_Block::DONT_DELETE,
            0);

    ACE_Message_Block message_block(&db,
            ACE_Message_Block::DONT_DELETE,
            0);

    if (recv_line(message_block) == -1)
    {
        sLog->outRemote("Recv error %s", ACE_OS::strerror(errno));
        return -1;
    }

    out_line = message_block.rd_ptr();

    return 0;
}

void take_connection(int sockfd) {

	int status;
	char *buff;

	/* chek for client ip */
	if (strcmp(client_ip, "127.0.0.1")) {
		close(sockfd);

		return;
	}

	send_line(sockfd, message(MSG_WELCOME), strlen(message(MSG_WELCOME)));

	if (helo_cmd(sockfd)) {
		close(sockfd);
		return;
	}

	buff = calloc(MAX_MSG_SIZE, sizeof(char));

	while (1) {
		memset(buff, '\0', MAX_MSG_SIZE);

		if (recv_line(sockfd, buff, MAX_MSG_SIZE - 1) <= 0) {
			free(buff);
			break;
		} else {
			status = lr_cmd(sockfd, buff);

			/* if something went wrong break */
			if (status <= -1) {
				break;
			/* if it went ok continue */
			} else if (status == 0) {
				continue;
			/* else: nothing happened, this command wasn't requested */
			} else {
				status = bye_cmd(sockfd, buff);

				if (status <= 0 ||
					send_line(
						sockfd,
						message(MSG_BAD_SYNTAX),
						strlen(message(MSG_BAD_SYNTAX))
					) < 0) {
					break;
				}
			}
		}
	}

	sleep(1);
	close(sockfd);
}

/* This function handles the connection on the passed socket from the 
 * passed client address and logs to the passed FD. The connection is 
 * processed as a web request and this function replies over the connected
 * socket.  Finally, the passed socket is closed at the end of the function. 
 */ 
void handle_connection(int sockfd, struct sockaddr_in *client_addr_ptr, int logfd) { 
   unsigned char *ptr, request[500], resource[500], log_buffer[500]; 
   int fd, length; 

   length = recv_line(sockfd, request); 
   
   sprintf(log_buffer, "From %s:%d \"%s\"\t", inet_ntoa(client_addr_ptr->sin_addr), ntohs(client_addr_ptr->sin_port), request); 

   ptr = strstr(request, " HTTP/"); // search for valid looking request 
   if(ptr == NULL) { // then this isn't valid HTTP 
      strcat(log_buffer, " NOT HTTP!\n"); 
   } else { 
      *ptr = 0; // terminate the buffer at the end of the URL 
      ptr = NULL; // set ptr to NULL (used to flag for an invalid request) 
      if(strncmp(request, "GET ", 4) == 0)  // get request 
         ptr = request+4; // ptr is the URL 
      if(strncmp(request, "HEAD ", 5) == 0) // head request 
         ptr = request+5; // ptr is the URL 
      if(ptr == NULL) { // then this is not a recognized request 
         strcat(log_buffer, " UNKNOWN REQUEST!\n"); 
      } else { // valid request, with ptr pointing to the resource name 
         if (ptr[strlen(ptr) - 1] == '/')  // for resources ending with '/' 
            strcat(ptr, "index.html");     // add 'index.html' to the end 
         strcpy(resource, WEBROOT);     // begin resource with web root path 
         strcat(resource, ptr);         //  and join it with resource path 
         fd = open(resource, O_RDONLY, 0); // try to open the file 
         if(fd == -1) { // if file is not found 
            strcat(log_buffer, " 404 Not Found\n"); 
            send_string(sockfd, "HTTP/1.0 404 NOT FOUND\r\n"); 
            send_string(sockfd, "Server: Tiny webserver\r\n\r\n"); 
            send_string(sockfd, "<html><head><title>404 Not Found</title></head>"); 
            send_string(sockfd, "<body><h1>URL not found</h1></body></html>\r\n"); 
         } else {      // otherwise, serve up the file 
            strcat(log_buffer, " 200 OK\n"); 
            send_string(sockfd, "HTTP/1.0 200 OK\r\n"); 
            send_string(sockfd, "Server: Tiny webserver\r\n\r\n"); 
            if(ptr == request + 4) { // then this is a GET request 
               if( (length = get_file_size(fd)) == -1) 
                  fatal("getting resource file size"); 
               if( (ptr = (unsigned char *) malloc(length)) == NULL) 
                  fatal("allocating memory for reading resource"); 
               read(fd, ptr, length); // read the file into memory 
               send(sockfd, ptr, length, 0);  // send it to socket 
               free(ptr); // free file memory 
            } 
            close(fd); // close the file 
         } // end if block for file found/not found 
      } // end if block for valid request 
   } // end if block for valid HTTP 
   timestamp(logfd); 
   length = strlen(log_buffer); 
   write(logfd, log_buffer, length); // write to the log 

   shutdown(sockfd, SHUT_RDWR); // close the socket gracefully
} 

int
send_recv(struct user *u, int child_no, struct user *users)
{
	//struct user *up = &u;
	char *buf;
	ssize_t len;

	(void) fprintf(stderr, "-----------------------------------\n");
	len = recv_line(u->socket, &buf);
	if (len == -1){ // 受信失敗。無視する
		(void) fprintf(stderr, "error");
		return(0);
	}
	if(len == 0){
		(void) fprintf(stderr, "recv:EOF\n");
		return(-1);
	}
	char *cmd, *body;
	client_cmd_parse(buf, &cmd, &body);

	if(strncmp(cmd, "JOIN", sizeof("JOIN")) == 0){
		fprintf(stderr, "JOIN CMD..\n");
		if(!set_name(u, body)){
			disconnect(u);
		}
		(void) fprintf(stderr, "name= '%s'\n", u->name);
	}else if(strncmp(cmd, "SAY", sizeof("SAY")) == 0){
		fprintf(stderr, "SAY CMD..\n");

		push_to_everybody(users, generate_sayed_cmd(u, body));
		/*
		int send_len = strlen(body);
		fprintf(stderr, "body...'%s', len=%d\n", body, send_len);
		generate_sayed_cmd(u, body);
		int i;
		for (i = 0; i < MAX_CHILD; i++) {
			if(users[i].socket != -1){
				fprintf(stderr, "sending....to [user:%d]\n", users[i].no);
				len = send(users[i].socket, body, (size_t) send_len, 0);
				if (len == -1) {
					perror("send");
					return(-1);
				}
			}
		}
		*/
	}else if(strncmp(cmd, "LEAVE", sizeof("LEAVE")) == 0){
		fprintf(stderr, "LEAVE CMD..\n");
	}
	//free(body);
	free(cmd);
	free(buf);
	return(0);
}

char* nrecv(int clientfd)
{
    int read = 0, nread = 0;
    char head_line[100];
    char content_len[] = "Content-Length: ";
    char *p = NULL;
    char *buf = NULL;
    int body_len = 0;
    /*printf("step into nrecv!\n");*/
    do {
        if (recv_line(clientfd,head_line) <= 0)
            return NULL;
    } while(strstr(head_line, content_len) == NULL);

    p = head_line + 16;
    while(*p != '\0') {
        body_len = body_len * 10 + *p - '0';
        p++;
    }
    /*printf("nrecv 85\n");*/
    do {
        if(recv_line(clientfd, head_line) < 0)
            return NULL;
        if(strlen(head_line) == 0)
            break;
    } while(1);
    /*printf("nrecv 92\n");*/
    if((buf = (char *) malloc((body_len+1) * sizeof(char))) == NULL)
        return NULL;
    do {
        read = recv(clientfd, buf + nread, body_len-nread, 0);
        if(read < 0) {
            return NULL;
        }
        nread += read;
    } while(read > 0);
    /*printf("nrecv 102\n");*/
    *(buf+body_len) = '\0';
    /*	printf("will out the nrecv\n");*/
    return buf;
}

int http_response_status(http_client_ptr_t http_client)/* 远程WEB服务器的http响应代码，如404*/
{
	//char *temp[5];
	int flag;
	char recvbuf[RECVSIZE+1];
	bzero(recvbuf,RECVSIZE+1);
	flag = recv_line(recvbuf, &(http_client->network));
	if(flag == -1) {
		fprintf(stderr, "Error in http_response_status(). recv error.\n");
		return flag;
	}
	else if (flag < 2) {
		fprintf(stderr, "Error in http_response_status(). recv error.\n");
		fprintf(stderr, "Now flag is %d, recvbuf is %s.\n",flag ,recvbuf);
		return -1;
	}
	//mysplit(temp, recvbuf, " ");
	http_client->status = get_status(recvbuf);
	bzero(recvbuf,RECVSIZE);
	flag = recv_line(recvbuf, &(http_client->network));
	if(flag <= -1){
		fprintf(stderr, "Error in http_response_status(). recv error.\n");
		return -1;
	}
	while(strcmp(recvbuf,"\r\n")!=0) {
//		mysplit(temp, recvbuf, ":");
//		if(strcasecmp(temp[0], "Content-Length")==0) {
//			http_client->content_length = atol(temp[1]);
//		}
//		bzero(recvbuf,RECVSIZE);
		flag = recv_line(recvbuf, &(http_client->network));
		if(flag <= -1){
			fprintf(stderr, "Error in http_response_status(). recv error.\n");
			return -1;
		}
	}
	//fprintf(stderr,"http get status success!\n");
	return http_client->status;
}

static void
dump_residual (socket_descriptor_t sd,
	       int timeout,
	       volatile int *signal_received)
{
  char buf[256];
  while (true)
    {
      if (!recv_line (sd, buf, sizeof (buf), timeout, true, NULL, signal_received))
	return;
      chomp (buf);
      msg (D_PROXY, "PROXY HEADER: '%s'", buf);
    }
}

/**
 * Returns -1 if no socket, error or client asked to stop tests, 0 otherwise.
 */
static int
hosts_read_client (struct arglist *globals)
{
  struct timeval tv;
  int e;
  fd_set rd;
  int rsoc;

  if (g_soc == -1)
    return 0;


  rsoc = openvas_get_socket_from_connection (g_soc);
  if (rsoc == -1)
    return -1;

  FD_ZERO (&rd);
  FD_SET (rsoc, &rd);

  for (;;)
    {
      tv.tv_sec = 0;
      tv.tv_usec = 1000;
      e = select (rsoc + 1, &rd, NULL, NULL, &tv);
      if (e < 0 && errno == EINTR)
        continue;
      else
        break;
    }

  if (e > 0 && FD_ISSET (rsoc, &rd) != 0)
    {
      int f, n;
      char buf[4096];
      n = recv_line (g_soc, buf, sizeof (buf) - 1);
      if (n <= 0)
        return -1;

      f = ntp_parse_input (globals, buf);
      if (f == NTP_STOP_WHOLE_TEST)
        return -1;
      else if (f == NTP_PAUSE_WHOLE_TEST)
        hosts_pause_all ();
      else if (f == NTP_RESUME_WHOLE_TEST)
        hosts_resume_all ();
    }

  return 0;
}

static int read_version(conn_t *conn)
{
	char buf[1024];
	unsigned i;
	if(!recv_line(conn, buf, sizeof(buf)))
	    return -1;
	if (!strcmp(buf, "UNKNOWN COMMAND\n"))
	    return -2;

	conn->version = strdup(buf);
	OOM_CHECK(conn->version);
	for (i=0;i<strlen(conn->version);i++)
		    if (conn->version[i] == '\n')
			conn->version[i] = ' ';
	return 0;
}

/*
 * Extract the Proxy-Authenticate header from the stream.
 * Consumes all headers.
 */
static int
get_proxy_authenticate (socket_descriptor_t sd,
		        int timeout,
			char **data,
			struct gc_arena *gc,
		        volatile int *signal_received)
{
  char buf[256];
  int ret = HTTP_AUTH_NONE;
  while (true)
    {
      if (!recv_line (sd, buf, sizeof (buf), timeout, true, NULL, signal_received))
	{
	  *data = NULL;
	  return HTTP_AUTH_NONE;
	}
      chomp (buf);
      if (!strlen(buf))
	return ret;
      if (ret == HTTP_AUTH_NONE && !strncmp(buf, "Proxy-Authenticate: ", 20))
	{
	  if (!strncmp(buf+20, "Basic ", 6))
	    {
	      msg (D_PROXY, "PROXY AUTH BASIC: '%s'", buf);
	      *data = string_alloc(buf+26, gc);
	      ret = HTTP_AUTH_BASIC;
	    }
#if PROXY_DIGEST_AUTH
	  else if (!strncmp(buf+20, "Digest ", 7))
	    {
	      msg (D_PROXY, "PROXY AUTH DIGEST: '%s'", buf);
	      *data = string_alloc(buf+27, gc);
	      ret = HTTP_AUTH_DIGEST;
	    }
#endif
#if NTLM
	  else if (!strncmp(buf+20, "NTLM", 4))
	    {
	      msg (D_PROXY, "PROXY AUTH HTLM: '%s'", buf);
	      *data = NULL;
	      ret = HTTP_AUTH_NTLM;
	    }
#endif
	}
    }
}

int main(int argc, char *argv[]){

	int sockfd;
	struct hostent *host_info;
	struct sockaddr_in target_addr;
	unsigned char buffer[4096];
	
	if (argc < 2){
		printf("Usage: %s <hostname>\n",argv[1]);
	}

	/* tries to resolve the hostname. if it failes, a null pointer is returned */
	if((host_info=gethostbyname(argv[1]))==NULL){
		printf("Could not resolve hostname %s",argv[1]);
	}

	/* creates a usual tcp socket for internet protocol family */
	if((sockfd=socket(PF_INET, SOCK_STREAM,0))==0){
		printf("Error creating socket\n");
	}
	
	target_addr.sin_family=AF_INET;		/* sets the host byte order */
	target_addr.sin_port=htons(80);		/* changes the integer port number from host byte order into network byte order */
	target_addr.sin_addr = *((struct in_addr *) host_info->h_addr);		/* sets the address we are trying to connect. the information is received from hostent struct */
	memset(&(target_addr.sin_zero),'\0',8);		/* padding to zero */

	/* connect function call on socket tries to connect 
	see http://linux.die.net/man/2/connect */
	if(connect(sockfd, (struct sockaddr *)&target_addr, sizeof(struct sockaddr)) == -1){
		printf("Error when connecting to the remote server\n");
	}

	send_string(sockfd, "HEAD / HTTP/1.0\r\n\r\n");

	while(recv_line(sockfd, buffer)){
		/* strncasecmü is a string comparsion functon from string.h that compares the first n bytes of the two strings, ignoring capit. 
		   it retunrs 0 on success. If it found that string, it will remove that and print out everything after that */
		if(strncasecmp(buffer, "Server:",7)==0){
			printf("The webserver for the hostname %s is %s\n", argv[1], buffer+8);
			exit(0);
		}
	}
	printf("Server line not found\n");
	exit(1);

}

static void parse_queue(conn_t *conn, char* buf, size_t len, unsigned idx)
{
	do {
		double tim;
		const char *t = strchr(buf, ' ');
		if(!t)
			continue;
		if(sscanf(t,"%lf", &tim) != 1)
			continue;
		++global.n;
		global.tasks = realloc(global.tasks, sizeof(*global.tasks)*global.n);
		OOM_CHECK(global.tasks);
		global.tasks[global.n-1].line = strdup(buf);
		OOM_CHECK(global.tasks[global.n-1].line);
		global.tasks[global.n-1].tim  = tim;
		global.tasks[global.n-1].clamd_no = idx + 1;
	} while (recv_line(conn, buf, len) && buf[0] == '\t' && strcmp("END\n", buf) != 0);
}

/**
* Main - Run through the steps of configuring, greeting, getting a name, thanking,
* and then quitting
*/
int main(void) {
	char buff[BUFF_LENGTH];

	// Setup the hardware
	init_hardware();

	// Wait until the USB port is configured and ready to go
	draw_centred(17, "Waiting for");
	draw_centred(24, "computer...");
	show_screen();
	while (!usb_configured() || !usb_serial_get_control());

	// Prompt the user for their name, and wait until they enter it
	clear_screen();
	draw_centred(17, "Waiting for");
	draw_centred(24, "username...");
	show_screen();
	send_line("Hello!");
	send_line("Could you please tell me your name:");
	recv_line(buff, BUFF_LENGTH);
	usb_serial_putchar('\n');

	// Display their name on the Teensy and prompt them to exit
	char buff2[BUFF_LENGTH + 8];
	sprintf(buff2, "Thanks %s!", buff);
	clear_screen();
	draw_centred(21, buff2);
	show_screen();
	send_line("Press 'q' to exit...");
	while (usb_serial_getchar() != 'q');

	// Display the finished information
	clear_screen();
	draw_centred(21, "Goodbye!");
	show_screen();
	send_line("\r");
	send_line("Done! Goodbye!");
	while (1);

	// We'll never get here...
	return 0;
}

int RASocket::svc(void)
{
    //! Subnegotiation may differ per client - do not react on it
    subnegotiate();

    if (send("Authentication required\r\n") == -1)
        return -1;

    if (authenticate() == -1)
    {
        (void) send("Authentication failed\r\n");
        return -1;
    }

    // send motd
    if (send(std::string(sWorld->GetMotd()) + "\r\n") == -1)
        return -1;

    for (;;)
    {
        // show prompt
        const char* tc_prompt = "QUANTUMCORE SERVER DAEMON> ";
        if (size_t(peer().send(tc_prompt, strlen(tc_prompt))) != strlen(tc_prompt))
            return -1;

        std::string line;

        if (recv_line(line) == -1)
            return -1;

        if (process_command(line) == -1)
            return -1;
    }

    return 0;
}

bool
establish_http_proxy_passthru (struct http_proxy_info *p,
			       socket_descriptor_t sd, /* already open to proxy */
			       const char *host,       /* openvpn server remote */
			       const int port,         /* openvpn server port */
			       struct buffer *lookahead,
			       volatile int *signal_received)
{
  struct gc_arena gc = gc_new ();
  char buf[256];
  char buf2[128];
  char get[80];
  int status;
  int nparms;
  bool ret = false;

  /* get user/pass if not previously given or if --auto-proxy is being used */
  if (p->auth_method == HTTP_AUTH_BASIC
      || p->auth_method == HTTP_AUTH_NTLM)
    get_user_pass_http (p, false);

  /* format HTTP CONNECT message */
  openvpn_snprintf (buf, sizeof(buf), "CONNECT %s:%d HTTP/%s\r\nHOST: %s:%d",
		    host,
		    port,
		    p->options.http_version,
		    host,
		    port);

  msg (D_PROXY, "Send to HTTP proxy: '%s'", buf);

  /* send HTTP CONNECT message to proxy */
  if (!send_line_crlf (sd, buf))
    goto error;

  /* send User-Agent string if provided */
  if (p->options.user_agent)
    {
      openvpn_snprintf (buf, sizeof(buf), "User-Agent: %s",
			p->options.user_agent);
      if (!send_line_crlf (sd, buf))
	goto error;
    }

  /* auth specified? */
  switch (p->auth_method)
    {
    case HTTP_AUTH_NONE:
      break;

    case HTTP_AUTH_BASIC:
      openvpn_snprintf (buf, sizeof(buf), "Proxy-Authorization: Basic %s",
			username_password_as_base64 (p, &gc));
      msg (D_PROXY, "Attempting Basic Proxy-Authorization");
      dmsg (D_SHOW_KEYS, "Send to HTTP proxy: '%s'", buf);
      openvpn_sleep (1);
      if (!send_line_crlf (sd, buf))
	goto error;
      break;

#if NTLM
    case HTTP_AUTH_NTLM:
    case HTTP_AUTH_NTLM2:
      /* keep-alive connection */
      openvpn_snprintf (buf, sizeof(buf), "Proxy-Connection: Keep-Alive");
      if (!send_line_crlf (sd, buf))
	goto error;

      openvpn_snprintf (buf, sizeof(buf), "Proxy-Authorization: NTLM %s",
			ntlm_phase_1 (p, &gc));
      msg (D_PROXY, "Attempting NTLM Proxy-Authorization phase 1");
      dmsg (D_SHOW_KEYS, "Send to HTTP proxy: '%s'", buf);
      openvpn_sleep (1);
      if (!send_line_crlf (sd, buf))
	goto error;
      break;
#endif

    default:
      ASSERT (0);
    }

  /* send empty CR, LF */
  openvpn_sleep (1);
  if (!send_crlf (sd))
    goto error;

  /* receive reply from proxy */
  if (!recv_line (sd, buf, sizeof(buf), p->options.timeout, true, NULL, signal_received))
    goto error;

  /* remove trailing CR, LF */
  chomp (buf);

  msg (D_PROXY, "HTTP proxy returned: '%s'", buf);

  /* parse return string */
  nparms = sscanf (buf, "%*s %d", &status);

  /* check for a "407 Proxy Authentication Required" response */
//.........这里部分代码省略.........

// sending email
void sendemail(char *email, char *body)
{
    int sockfd;
    int retval = 0;
    int err;
    char *host_name = "smtp.fakessh.eu";
    struct sockaddr_in their_addr;
    struct hostent *hent;
    char buf[1500] = {0};
    char rbuf[1500] = {0};
    char login[128] = {0};
    char pass[128] = {0};

    //initialize SSL
    SSL_CTX *ctx;
    SSL *ssl;
    SSL_METHOD *meth;

    SSLeay_add_ssl_algorithms();
    meth = SSLv23_method();
    SSL_load_error_strings();
    SSL_library_init();
    ctx = SSL_CTX_new(meth);
    CHK_NULL(ctx);

    fd_set readfds;
    struct timeval timeout;

    //Define a timeout for resending data.
    timeout.tv_sec = 2;
    timeout.tv_usec = 0;

#ifdef WIN32
    WSADATA WSAData;
    WSAStartup(MAKEWORD(2, 2), &WSAData);
#endif

    hent = gethostbyname(host_name);
    memset(&their_addr, 0, sizeof(their_addr));
    their_addr.sin_family = AF_INET;
    their_addr.sin_port = htons(587);
    their_addr.sin_addr = *((struct in_addr *)hent->h_addr);

    //connecting mail server and reconnecting if no response in 2 seconds
    sockfd = open_socket((struct sockaddr *)&their_addr);
    memset(rbuf,0,1500);
    FD_ZERO(&readfds);
    FD_SET(sockfd, &readfds);
    retval = select(sockfd+1, &readfds, NULL, NULL, &timeout);
    while(retval <= 0)
    {
        printf("reconnect...\n");
        sleep(2);
        close(sockfd);
        sockfd = open_socket((struct sockaddr *)&their_addr);
        memset(rbuf,0,1500);
        FD_ZERO(&readfds);
        FD_SET(sockfd, &readfds);
        retval = select(sockfd+1, &readfds, NULL, NULL, &timeout);
    }

    memset(rbuf, 0, 1500);
    recv(sockfd, rbuf, 1500, 0);
    printf("%s\n", rbuf);

    //EHLO
    memset(buf, 0, 1500);
    sprintf(buf, "EHLO localhost\r\n");
    send(sockfd, buf, strlen(buf), 0);
    memset(rbuf, 0, 1500);
    recv(sockfd, rbuf, 1500, 0);
    printf("%s\n", rbuf);

    //START_TLS with OPENSSL
    memset(buf,0, 1500);
    sprintf(buf, "STARTTLS\r\n");
    send(sockfd, buf, strlen(buf), 0);
    memset(rbuf, 0, 1500);
    recv(sockfd, rbuf, 1500, 0);
    printf("%s\n", rbuf);


    //AUTH LOGIN
    ssl   =   SSL_new(ctx);
    CHK_NULL(ssl);
    SSL_set_fd   (ssl,   sockfd);
    err   =   SSL_connect(ssl);
    CHK_SSL(err);

    memset(buf,0, 1500);
    sprintf(buf, "EHLO localhost\r\n");
    send_line(ssl,buf);
    recv_line(ssl);


    memset(buf,0, 1500);
    sprintf(buf, "AUTH LOGIN\r\n");
    send_line(ssl,buf);
    recv_line(ssl);
//.........这里部分代码省略.........

int
ftp_log_in (int soc, char *username, char *passwd)
{
  char buf[1024];
  int n;
  int counter;

  buf[sizeof (buf) - 1] = '\0';
  n = recv_line (soc, buf, sizeof (buf) - 1);
  if (n <= 0)
    return (1);

  if (strncmp (buf, "220", 3) != 0)
    {
      return 1;
    }

  counter = 0;
  while (buf[3] == '-' && n > 0 && counter < 1024)
    {
      n = recv_line (soc, buf, sizeof (buf) - 1);
      counter++;
    }

  if (counter >= 1024)
    return 1;                   /* Rogue FTP server */

  if (n <= 0)
    return 1;


  snprintf (buf, sizeof (buf), "USER %s\r\n", username);        /* RATS: ignore */
  write_stream_connection (soc, buf, strlen (buf));
  n = recv_line (soc, buf, sizeof (buf) - 1);
  if (n <= 0)
    return 1;
  if (strncmp (buf, "230", 3) == 0)
    {
      counter = 0;
      while (buf[3] == '-' && n > 0 && counter < 1024)
        {
          n = recv_line (soc, buf, sizeof (buf) - 1);
          counter++;
        }
      return 0;
    }

  if (strncmp (buf, "331", 3) != 0)
    {
      return 1;
    }

  counter = 0;
  n = 1;
  while (buf[3] == '-' && n > 0 && counter < 1024)
    {
      n = recv_line (soc, buf, sizeof (buf) - 1);
      counter++;
    }

  if (counter >= 1024)
    return 1;


  snprintf (buf, sizeof (buf), "PASS %s\r\n", passwd);  /* RATS: ignore */
  write_stream_connection (soc, buf, strlen (buf));
  n = recv_line (soc, buf, sizeof (buf) - 1);
  if (n <= 0)
    return 1;

  if (strncmp (buf, "230", 3) != 0)
    {
      return 1;
    }

  counter = 0;
  n = 1;
  while (buf[3] == '-' && n > 0 && counter < 1024)
    {
      n = recv_line (soc, buf, sizeof (buf) - 1);
      counter++;
    }

  return 0;
}