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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
ftp.cpp
资源名称：myftp.zip　[点击查看]
上传用户：kkaqas
上传日期：2007-01-07
资源大小：38k
文件大小：7k
源码类别：

Ftp客户端

开发平台：

Visual C++

ftp.cpp：源码内容
  1. #include <windows.h>
  2. #include <winsock.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <time.h>
  7. #include "tcp.h"
  8. #include "ftp.h"
  10. int g_code =0;
  11. char g_reply[2000];
  12. int sd_login =-1;
  14. void log_msg(char *);
  16. int ftp_cmd(int sd, char *cmd, int success_code)
  17. {
  18.   int code;
  20.   if(tcp_send(sd, cmd, strlen(cmd), 5) !=(int)strlen(cmd))
  21.   {
  22.   log_msg("ftp_cmd: tcp_send failed");
  23.   return -1;
  24.   }
  25.   if((code =get_reply(sd)) !=success_code)
  26.   {
  27.       log_msg(cmd);
  28.   log_msg(g_reply);
  29.   return -2;
  30.   }
  31.   return 0;
  32. }
  34. int ftp_login(char *hostname, char *user_name, char *passwd)
  35. {
  36.   int sd, ret;
  37.   char cmds[100];
  38.   
  39.   if((sd =tcp_connect(hostname, 21, 10)) <0)
  40.     return -1;
  41.   if((ret =get_reply(sd)) !=220)
  42.   {
  43.     closesocket(sd);
  44.     return -1;
  45.   }
  46.   sprintf(cmds, "USER %srn", user_name);
  47.   if(ftp_cmd(sd, cmds, 331) <0)
  48.   {
  49.     closesocket(sd);
  50.     return -1;
  51.   }
  52.   sprintf(cmds, "PASS %srn", passwd);
  53.   if(ftp_cmd(sd, cmds, 230) <0)
  54.   {
  55.     closesocket(sd);
  56.     return -1;
  57.   }
  58.   sd_login =sd;
  60.   return sd;
  61. }
  63. int ftp_chdir(int sd, char *path)
  64. {
  65.   char cmds[100];
  66.   
  67.   sprintf(cmds, "CWD %srn", path);
  68.   if(ftp_cmd(sd, cmds, 250) <0)
  69.   return -1;
  70.   return 0;
  71. }
  73. int ftp_get_size(int sd, char *file_remote)
  74. {
  75.   int size =0;
  76.   char cmds[100];
  77.   
  78.   sprintf(cmds, "SIZE %srn", file_remote);
  79.   if(ftp_cmd(sd, cmds, 213) <0)
  80.     return 0;
  81.   if(sscanf(g_reply, "%*d %d", &size) !=1)
  82.     return 0;
  84.   return size;
  85. }
  87. int ftp_get_time(int sd, char *file_remote, char *pstime)
  88. {
  89.   char cmds[100];
  91.   sprintf(cmds, "MDTM %srn", file_remote);
  92.   if(ftp_cmd(sd, cmds, 213) <0)
  93.     return -1;
  94.   strncpy(pstime, &g_reply[4], 14);
  96.   return 0;
  97. }
  99. int ftp_get_file(int sd, char *file_remote, char *file_local, int file_len, int max_wait_time)
  100. {
  101.   char temp[200], cmds[300];
  102.   int len, len_recved =0, ret =0, code;
  103.   char buf[4096];
  104.   FILE *fp =NULL;
  105.   int sd_data =-1;
  106.   
  107.   temp[0] =0;
  108.   if(ftp_cmd(sd, "TYPE Irn", 200) <0)
  109.   {
  110.     sprintf(temp, "ftp_get_file:TYPE I failed! sd=%d, file_remote:%s", sd, file_remote);
  111.     ret =-2;
  112.     goto f_exit;
  113.   }
  115.   if(file_len <=0)
  116.   if((file_len =ftp_get_size(sd, file_remote)) <=0)
  117.   {
  118.     sprintf(temp, "ftp_get_file:ftp_get_size failed! sd =%d, file_remote=%s, ret_len=%d", sd, file_remote, file_len);
  119.     ret =-3;
  120.     goto f_exit;
  121.   }
  123.   if((sd_data =initconn(sd)) <0)
  124.   {
  125.     sprintf(temp, "ftp_get_file:initconn failed! sd =%d, file_remote:%s", sd, file_remote);
  126.     ret =-4;
  127.     goto f_exit;
  128.   }
  129.   sprintf(cmds, "RETR %srn", file_remote);
  130.   if(ftp_cmd(sd, cmds, 150) <0)
  131.   {
  132.     sprintf(temp, "ftp_get_file:ftp_cmd failed! cmd:%s", cmds);
  133.     ret =-5;
  134.     goto f_exit;
  135.   }
  137.   if((sd_accept =tcp_accept(sd_data, 20)) <0)
  138.   {
  139.     sprintf(temp, "ftp_get_file:ftp_accept failed! sd=%d, sd_data=%d, file_remote=%s", sd, sd_data, file_remote);
  140.     ret =-6;
  141.     goto f_exit;
  142.   } 
  144.   len_recved =0;
  145.   if((fp =fopen(file_local, "wb")) ==NULL)
  146.   {
  147.     sprintf(temp, "ftp_get_file:open file for write failed! local_file:%s", file_local);
  148.     ret =-1;
  149.     goto f_exit;
  150.   }
  152.   while(len_recved < file_len)
  153.   {
  154.     if(file_len-len_recved <sizeof(buf)) len =file_len-len_recved;
  155.     else len =sizeof(buf);
  156.     if(tcp_recv(sd_accept, buf, len, max_wait_time) !=len)
  157.     {
  158.       sprintf(temp, "ftp_get_file:tcp_recv failed! len_recved:%d, file_len:%d, file_remote:%s", len_recved, file_len, file_remote);
  159.       ret =-7;
  160.       get_reply(sd);
  161.       goto f_exit;
  162.     }
  163.     if(fwrite(buf, len, 1, fp) !=1)
  164.     {
  165.       sprintf(temp, "ftp_get_file: fwrite failed! len_recved:%d, file_local:%s", len_recved, file_local);
  166.       get_reply(sd);
  167.       ret =-8;
  168.       goto f_exit;
  169.     }
  170.     len_recved +=len;
  171.   }
  172.   tcp_close(sd_accept); sd_accept =-1;
  173.   ret =len_recved;
  174.   if((code =get_reply(sd)) !=226)
  175.   {
  176.     sprintf(temp, "ftp_get_file:get_reply failed after recv success! ret_code:%d, reply string:%s", code, g_reply);
  177.     goto f_exit;
  178.   }
  180. f_exit:
  181.   if(sd_accept >=0) tcp_close(sd_accept);
  182.   if(sd_data >=0) tcp_close(sd_data);
  183.   sd_accept =-1;
  184.   sd_data =-1;
  185.   if(fp) fclose(fp);
  186.   if(ret <0)
  187.   {
  188.   sprintf(temp, "ftp_get_file failed. ret=%d", ret);
  189.   log_msg(temp);
  190.   remove(file_local);
  191.   }
  193.   return ret;
  194. }
  196. int ftp_put_file(int sd, char *file_local, int pos, char *file_remote, int max_wait_time)
  197. {
  198.   char cmds[300];
  199.   int len, file_len =0, len_sent =0, ret =0, code;
  200.   char buf[4096];
  201.   FILE *fp =NULL;
  202.   int sd_data;
  203.   
  204.   if((fp =fopen(file_local, "r")) ==NULL)
  205.   {
  206.     ret =-1;
  207.     goto f_exit;
  208.   }
  209.   fseek(fp, 0, SEEK_END);
  210.   file_len =ftell(fp)-pos;
  211.   if(file_len <0) return -1;
  212.   if(file_len ==0) return 0;
  213.   fseek(fp, pos, SEEK_SET);
  215.   if(ftp_cmd(sd, "TYPE Irn", 200) <0)
  216.   {
  217.     ret =-1;
  218.     goto f_exit;
  219.   }
  221.   if((sd_data =initconn(sd)) <0)
  222.   {
  223.     ret =-1;
  224.     goto f_exit;
  225.   }
  226.   sprintf(cmds, "STOR %srn", file_remote);
  227.   if(ftp_cmd(sd, cmds, 150) <0)
  228.   {
  229.     ret =-1;
  230.     goto f_exit;
  231.   }
  233.   if((sd_accept =tcp_accept(sd_data, 20)) <0)
  234.   {
  235.     ret =-1;
  236.     goto f_exit;
  237.   }
  238.   
  239.   len_sent =0;
  240.   while(len_sent < file_len)
  241.   {
  242.     if(file_len-len_sent <sizeof(buf)) len =file_len-len_sent;
  243.     else len =sizeof(buf);
  244.     if(fread(buf, len, 1, fp) !=1)
  245.     {
  246.       get_reply(sd);
  247.       ret =-1;
  248.       goto f_exit;
  249.     }
  250.     if(tcp_send(sd_accept, buf, len, max_wait_time) !=len)
  251.     {
  252.       ret =-1;
  253.       get_reply(sd);
  254.       goto f_exit;
  255.     }
  256.     len_sent +=len;
  257.   }
  258.   closesocket(sd_accept); sd_accept =-1;
  259.   if((code =get_reply(sd)) !=226)
  260.   {
  261.   goto f_exit;
  262.   }
  263.   ret =len_sent;
  265. f_exit:
  266.   if(sd_accept >=0) closesocket(sd_accept);
  267.   if(sd_data >=0) closesocket(sd_data);
  268.   sd_accept =-1;
  269.   sd_data =-1;
  270.   if(fp) fclose(fp);
  271.   if(buf) free(buf);
  273.   return ret;
  274. }
  276. int initconn(int sd)
  277. {
  278.   char *p1, *p2;
  279.   struct sockaddr_in addr1, addr2;
  280.   char temp[256];
  281.   int len;
  282.   int code, sd_data=-1;
  283.   
  284.   if((sd_data =tcp_bind(NULL, 0)) <0)
  285.     return -1;
  286.   len =sizeof(addr1);
  287.   if(getsockname(sd_login, (struct sockaddr *)&addr1, &len) <0)
  288.     return -1;
  289.   if(getsockname(sd_data, (struct sockaddr *)&addr2, &len) <0)
  290.     return -1;
  291.   p1 =(char *)&addr1.sin_addr;
  292.   p2 =(char *)&addr2.sin_port;
  293.   sprintf(temp, "PORT %d,%d,%d,%d,%d,%drn", ((int)p1[0]) &0xff, ((int)p1[1]) &0xff, (int)p1[2] &0xff, (int)p1[3]&0xff, (int)p2[0]&0xff, (int)p2[1]&0xff);
  294.   if(tcp_send(sd, temp, strlen(temp), 10) !=(int)strlen(temp))
  295.   {
  296.     closesocket(sd_data);
  297.     return -1;
  298.   }
  299.   if((code =get_reply(sd)) !=200)
  300.   {
  301.     closesocket(sd_data);
  302.     return -1;
  303.   }
  304.   return sd_data;
  305. }
  307. int get_reply(int sd)
  308. {
  309.   int i, code =0;
  311. again:
  312.   i =0;
  313.   memset(g_reply, 0, sizeof(g_reply));
  314.   while(1)
  315.   {
  316.     if(tcp_recv(sd, &g_reply[i], 1, 10) <=0)
  317.       break;
  318.     if(g_reply[i] =='r') g_reply[i] =' ';
  319.     if(g_reply[i] =='n')
  320.     {
  321.       g_reply[i] =' ';
  322.       if(sscanf(g_reply, "%d", &code) !=1)
  323.       {
  324.         return -1;
  325.       }
  326.       else break;
  327.     }
  328.     i++;
  329.   }
  330.   if(g_reply[3] =='-')
  331.   {
  332.   i =0;
  333.   goto again;
  334.   }
  335.   g_code =code;
  337.   return code;
  338. }
  340. void ftp_quit(int sd)
  341. {
  342.   ftp_cmd(sd, "QUITrn", 221);
  343.   closesocket(sd);
  344. }