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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > TCP/IP协议栈 > 查看源码
ftpcli.c
资源名称：export.zip　[点击查看]
上传用户：hepax88
上传日期：2007-01-03
资源大小：1101k
文件大小：28k
源码类别：

TCP/IP协议栈

开发平台：

Visual C++

ftpcli.c：源码内容
  1. /* Internet FTP client (interactive user)
  2.  * Copyright 1991 Phil Karn, KA9Q
  3.  */
  4. #include <stdio.h>
  5. #include "global.h"
  6. #include "mbuf.h"
  7. #include "session.h"
  8. #include "cmdparse.h"
  9. #include "proc.h"
  10. #include "tty.h"
  11. #include "socket.h"
  12. #include "ftp.h"
  13. #include "ftpcli.h"
  14. #include "commands.h"
  15. #include "netuser.h"
  16. #include "dirutil.h"
  17. #include "internet.h"
  19. #define POLLRATE 500 /* 500ms between more file polls */
  20. #define DIRBUF 256
  22. static int doascii(int argc,char *argv[],void *p);
  23. static int dobatch(int argc,char *argv[],void *p);
  24. static int dobinary(int argc,char *argv[],void *p);
  25. static int docompare(int argc,char *argv[],void *p);
  26. static int doftpcd(int argc,char *argv[],void *p);
  27. static int doget(int argc,char *argv[],void *p);
  28. static int dohash(int argc,char *argv[],void *p);
  29. static int doverbose(int argc,char *argv[],void *p);
  30. static int dolist(int argc,char *argv[],void *p);
  31. static int dols(int argc,char *argv[],void *p);
  32. static int domd5(int argc,char *argv[],void *p);
  33. static int domkdir(int argc,char *argv[],void *p);
  34. static int domcompare(int argc,char *argv[],void *p);
  35. static int domget(int argc,char *argv[],void *p);
  36. static int domput(int argc,char *argv[],void *p);
  37. static int doput(int argc,char *argv[],void *p);
  38. static int doquit(int argc,char *argv[],void *p);
  39. static int doread(int argc,char *argv[],void *p);
  40. static int dormdir(int argc,char *argv[],void *p);
  41. static int dotype(int argc,char *argv[],void *p);
  42. static int doupdate(int argc,char *argv[],void *p);
  43. static int getline(struct session *sp,char *prompt,char *buf,int n);
  44. static int getresp(struct ftpcli *ftp,int mincode);
  45. static long getsub(struct ftpcli *ftp,char *command,char *remotename,
  46. FILE *fp);
  47. static long putsub(struct ftpcli *ftp,char *remotename,char *localname);
  48. static int compsub(struct ftpcli *ftp,char *localname,char *remotename);
  49. static void sendport(FILE *fp,struct sockaddr_in *socket);
  50. static int keychar(int c);
  52. static char Notsess[] = "Not an FTP session!n";
  54. static struct cmds Ftpcmds[] = {
  55. "", donothing, 0, 0, NULL,
  56. "ascii", doascii, 0, 0, NULL,
  57. "batch", dobatch, 0, 0, NULL,
  58. "binary", dobinary, 0, 0, NULL,
  59. "cd", doftpcd, 0, 2, "cd <directory>",
  60. "compare", docompare, 0, 2, "compare <remotefile> [<localfile>]",
  61. "dir", dolist, 0, 0, NULL,
  62. "list", dolist, 0, 0, NULL,
  63. "get", doget, 0, 2, "get <remotefile> <localfile>",
  64. "hash", dohash, 0, 0, NULL,
  65. "ls", dols, 0, 0, NULL,
  66. "mcompare", domcompare, 0, 2, "mcompare <file> [<file> ...]",
  67. "md5", domd5, 0, 2, "md5 <file>",
  68. "mget", domget, 0, 2, "mget <file> [<file> ...]",
  69. "mkdir", domkdir, 0, 2, "mkdir <directory>",
  70. "mput", domput, 0, 2, "mput <file> [<file> ...]",
  71. "nlst", dols, 0, 0, NULL,
  72. "quit", doquit, 0, 0, NULL,
  73. "read", doread, 0, 2, "read <remotefile>",
  74. "rmdir", dormdir, 0, 2, "rmdir <directory>",
  75. "put", doput, 0, 2, "put <localfile> <remotefile>",
  76. "type", dotype, 0, 0, NULL,
  77. "update", doupdate, 0, 0, NULL,
  78. "verbose", doverbose, 0, 0, NULL,
  79. NULL, NULL, 0, 0, NULL,
  80. };
  82. /* Handle top-level FTP command */
  83. int
  84. doftp(argc,argv,p)
  85. int argc;
  86. char *argv[];
  87. void *p;
  88. {
  89. struct session *sp;
  90. struct ftpcli ftp;
  91. struct sockaddr_in fsocket;
  92. int resp,vsave;
  93. char *bufsav,*cp;
  94. FILE *control;
  95. int s;
  97. /* Allocate a session control block */
  98. if((sp = newsession(Cmdline,FTP,1)) == NULL){
  99. printf("Too many sessionsn");
  100. return 1;
  101. }
  102. sp->inproc = keychar;
  103. memset(&ftp,0,sizeof(ftp));
  104. ftp.control = ftp.data = NULL;
  105. ftp.verbose = V_NORMAL;
  107. sp->cb.ftp = &ftp; /* Downward link */
  108. ftp.session = sp; /* Upward link */
  110. fsocket.sin_family = AF_INET;
  111. if(argc < 3)
  112. fsocket.sin_port = IPPORT_FTP;
  113. else
  114. fsocket.sin_port = atoi(argv[2]);
  116. if(SETSIG(EABORT)){
  117. keywait(NULL,1);
  118. freesession(sp);
  119. return 1;
  120. }
  121. printf("Resolving %s...n",argv[1]);
  122. if((fsocket.sin_addr.s_addr = resolve(argv[1])) == 0){
  123. printf(Badhost,argv[1]);
  124. keywait(NULL,1);
  125. freesession(sp);
  126. return 1;
  127. }
  128. /* Open the control connection */
  129. if((s = socket(AF_INET,SOCK_STREAM,0)) == -1){
  130. printf("Can't create socketn");
  131. keywait(NULL,1);
  132. freesession(sp);
  133. return 1;
  134. }
  135. if(SETSIG(EABORT)){
  136. goto quit;
  137. }
  138. sp->network = control = ftp.control = fdopen(s,"r+t");
  139. settos(s,LOW_DELAY);
  140. printf("Trying %s...n",psocket(&fsocket));
  141. if(connect(s,(struct sockaddr *)&fsocket,sizeof(fsocket)) == -1){
  142. perror("Connect failed");
  143. goto quit;
  144. }
  145. printf("Connectedn");
  147. /* Wait for greeting from server */
  148. resp = getresp(&ftp,200);
  150. if(resp >= 400)
  151. goto quit;
  152. /* Now process responses and commands */
  154. if(SETSIG(EABORT)){
  155. /* Come back here after a ^C in command state */
  156. resp = 200;
  157. }
  158. while(resp != -1){
  159. switch(resp){
  160. case 220:
  161. /* Sign-on banner; prompt for and send USER command */
  162. getline(sp,"Enter user name: ",ftp.buf,LINELEN);
  163. /* Send the command only if the user response
  164.  * was non-null
  165.  */
  166. if(ftp.buf[0] != 'n'){
  167. fprintf(control,"USER %s",ftp.buf);
  168. resp = getresp(&ftp,200);
  169. } else
  170. resp = 200; /* dummy */
  171. break;
  172. case 331:
  173. /* turn off echo */
  174. sp->ttystate.echo = 0;
  175. getline(sp,"Password: ",ftp.buf,LINELEN);
  176. printf("n");
  177. /* Turn echo back on */
  178. sp->ttystate.echo = 1;
  179. /* Send the command only if the user response
  180.  * was non-null
  181.  */
  182. if(ftp.buf[0] != 'n'){
  183. fprintf(control,"PASS %s",ftp.buf);
  184. resp = getresp(&ftp,200);
  185. } else
  186. resp = 200; /* dummy */
  187. break;
  188. case 230: /* Successful login */
  189. /* Find out what type of system we're talking to */
  190. printf("ftp> systn");
  191. fprintf(control,"SYSTn");
  192. resp = getresp(&ftp,200);
  193. break;
  194. case 215:
  195. /* Response to SYST command */
  196. cp = strchr(ftp.line,' ');
  197. if(cp != NULL && strnicmp(cp+1,System,strlen(System)) == 0){
  198. ftp.type = IMAGE_TYPE;
  199. printf("Defaulting to binary moden");
  200. }
  201. resp = 200; /* dummy */
  202. break;
  203. default:
  204. /* Test the control channel first */
  205. if(sockstate(fileno(control)) == NULL){
  206. resp = -1;
  207. break;
  208. }
  209. getline(sp,"ftp> ",ftp.buf,LINELEN);
  211. /* Copy because cmdparse modifies the original */
  212. bufsav = strdup(ftp.buf);
  213. if((resp = cmdparse(Ftpcmds,ftp.buf,&ftp)) != -1){
  214. /* Valid command, free buffer and get another */
  215. FREE(bufsav);
  216. } else {
  217. /* Not a local cmd, send to remote server */
  218. fputs(bufsav,control);
  219. FREE(bufsav);
  221. /* Enable display of server response */
  222. vsave = ftp.verbose;
  223. ftp.verbose = V_NORMAL;
  224. resp = getresp(&ftp,200);
  225. ftp.verbose = vsave;
  226. }
  227. }
  228. }
  229. quit: cp = sockerr(fileno(control));
  230. printf("Closed: %sn",cp != NULL ? cp : "EOF");
  232. if(ftp.fp != NULL && ftp.fp != stdout)
  233. fclose(ftp.fp);
  234. if(ftp.data != NULL)
  235. fclose(ftp.data);
  236. if(ftp.control != NULL){
  237. fclose(ftp.control);
  238. ftp.control = NULL;
  239. sp->network = NULL;
  240. }
  241. keywait(NULL,1);
  242. if(ftp.session != NULL)
  243. freesession(ftp.session);
  244. return 0;
  245. }
  247. /* Control verbosity level */
  248. static int
  249. doverbose(argc,argv,p)
  250. int argc;
  251. char *argv[];
  252. void *p;
  253. {
  254. register struct ftpcli *ftp;
  256. if((ftp = (struct ftpcli *)p) == NULL)
  257. return -1;
  258. return setshort(&ftp->verbose,"Verbose",argc,argv);
  259. }
  260. /* Enable/disable command batching */
  261. static int
  262. dobatch(argc,argv,p)
  263. int argc;
  264. char *argv[];
  265. void *p;
  266. {
  267. register struct ftpcli *ftp;
  269. if((ftp = (struct ftpcli *)p) == NULL)
  270. return -1;
  271. return setbool(&ftp->batch,"Command batching",argc,argv);
  272. }
  273. /* Enable/disable update flag */
  274. static int
  275. doupdate(argc,argv,p)
  276. int argc;
  277. char *argv[];
  278. void *p;
  279. {
  280. register struct ftpcli *ftp;
  282. if((ftp = (struct ftpcli *)p) == NULL)
  283. return -1;
  284. return setbool(&ftp->update,"Update with MD5",argc,argv);
  285. }
  286. /* Set verbosity to high (convenience command) */
  287. static int
  288. dohash(argc,argv,p)
  289. int argc;
  290. char *argv[];
  291. void *p;
  292. {
  293. register struct ftpcli *ftp;
  295. if((ftp = (struct ftpcli *)p) == NULL)
  296. return -1;
  297. ftp->verbose = V_HASH;
  298. return 0;
  299. }
  301. /* Close session */
  302. static int
  303. doquit(argc,argv,p)
  304. int argc;
  305. char *argv[];
  306. void *p;
  307. {
  308. register struct ftpcli *ftp;
  310. ftp = (struct ftpcli *)p;
  311. if(ftp == NULL)
  312. return -1;
  313. fprintf(ftp->control,"QUITn");
  314. getresp(ftp,200); /* Get the closing message */
  315. getresp(ftp,200); /* Wait for the server to close */
  316. return -1;
  317. }
  319. /* Translate 'cd' to 'cwd' for convenience */
  320. static int
  321. doftpcd(argc,argv,p)
  322. int argc;
  323. char *argv[];
  324. void *p;
  325. {
  326. register struct ftpcli *ftp;
  328. ftp = (struct ftpcli *)p;
  329. if(ftp == NULL)
  330. return -1;
  331. fprintf(ftp->control,"CWD %sn",argv[1]);
  332. return getresp(ftp,200);
  333. }
  334. /* Translate 'mkdir' to 'xmkd' for convenience */
  335. static int
  336. domkdir(argc,argv,p)
  337. int argc;
  338. char *argv[];
  339. void *p;
  340. {
  341. register struct ftpcli *ftp;
  343. ftp = (struct ftpcli *)p;
  344. if(ftp == NULL)
  345. return -1;
  346. fprintf(ftp->control,"XMKD %sn",argv[1]);
  347. return getresp(ftp,200);
  348. }
  349. /* Translate 'rmdir' to 'xrmd' for convenience */
  350. static int
  351. dormdir(argc,argv,p)
  352. int argc;
  353. char *argv[];
  354. void *p;
  355. {
  356. register struct ftpcli *ftp;
  358. ftp = (struct ftpcli *)p;
  359. if(ftp == NULL)
  360. return -1;
  361. fprintf(ftp->control,"XRMD %sn",argv[1]);
  362. return getresp(ftp,200);
  363. }
  364. static int
  365. dobinary(argc,argv,p)
  366. int argc;
  367. char *argv[];
  368. void *p;
  369. {
  370. char *args[2];
  372. args[1] = "I";
  373. return dotype(2,args,p);
  374. }
  375. static int
  376. doascii(argc,argv,p)
  377. int argc;
  378. char *argv[];
  379. void *p;
  380. {
  381. char *args[2];
  383. args[1] = "A";
  384. return dotype(2,args,p);
  385. }
  387. /* Handle "type" command from user */
  388. static int
  389. dotype(argc,argv,p)
  390. int argc;
  391. char *argv[];
  392. void *p;
  393. {
  394. register struct ftpcli *ftp;
  396. ftp = (struct ftpcli *)p;
  397. if(ftp == NULL)
  398. return -1;
  399. if(argc < 2){
  400. switch(ftp->type){
  401. case IMAGE_TYPE:
  402. printf("Imagen");
  403. break;
  404. case ASCII_TYPE:
  405. printf("Asciin");
  406. break;
  407. case LOGICAL_TYPE:
  408. printf("Logical bytesize %un",ftp->logbsize);
  409. break;
  410. }
  411. return 0;
  412. }
  413. switch(*argv[1]){
  414. case 'i':
  415. case 'I':
  416. case 'b':
  417. case 'B':
  418. ftp->type = IMAGE_TYPE;
  419. break;
  420. case 'a':
  421. case 'A':
  422. ftp->type = ASCII_TYPE;
  423. break;
  424. case 'L':
  425. case 'l':
  426. ftp->type = LOGICAL_TYPE;
  427. ftp->logbsize = atoi(argv[2]);
  428. break;
  429. default:
  430. printf("Invalid type %sn",argv[1]);
  431. return 1;
  432. }
  433. return 0;
  434. }
  435. /* Start receive transfer. Syntax: get <remote name> [<local name>] */
  436. static int
  437. doget(argc,argv,p)
  438. int argc;
  439. char *argv[];
  440. void *p;
  441. {
  442. char *remotename,*localname;
  443. register struct ftpcli *ftp;
  444. FILE *fp;
  445. char *mode;
  447. ftp = (struct ftpcli *)p;
  448. if(ftp == NULL){
  449. printf(Notsess);
  450. return 1;
  451. }
  452. remotename = argv[1];
  453. if(argc < 3)
  454. localname = remotename;
  455. else
  456. localname = argv[2];
  458. switch(ftp->type){
  459. case IMAGE_TYPE:
  460. case LOGICAL_TYPE:
  461. mode = WRITE_BINARY;
  462. break;
  463. case ASCII_TYPE:
  464. mode = WRITE_TEXT;
  465. break;
  466. }
  467. if((fp = fopen(localname,mode)) == NULL){
  468. printf("Can't write %s",localname);
  469. perror("");
  470. return 1;
  471. }
  472. getsub(ftp,"RETR",remotename,fp);
  473. fclose(fp);
  474. return 0;
  475. }
  476. /* Read file direct to screen. Syntax: read <remote name> */
  477. static int
  478. doread(argc,argv,p)
  479. int argc;
  480. char *argv[];
  481. void *p;
  482. {
  483. register struct ftpcli *ftp;
  485. if((ftp = (struct ftpcli *)p) == NULL){
  486. printf(Notsess);
  487. return 1;
  488. }
  489. getsub(ftp,"RETR",argv[1],stdout);
  490. return 0;
  491. }
  492. /* Get a collection of files */
  493. static int
  494. domget(argc,argv,p)
  495. int argc;
  496. char *argv[];
  497. void *p;
  498. {
  499. register struct ftpcli *ftp;
  500. FILE *files,*fp;
  501. char *buf,*mode;
  502. int i;
  503. long r;
  505. if((ftp = (struct ftpcli *)p) == NULL){
  506. printf(Notsess);
  507. return 1;
  508. }
  509. switch(ftp->type){
  510. case IMAGE_TYPE:
  511. case LOGICAL_TYPE:
  512. mode = WRITE_BINARY;
  513. break;
  514. case ASCII_TYPE:
  515. mode = WRITE_TEXT;
  516. break;
  517. }
  518. buf = mallocw(DIRBUF);
  519. ftp->state = RECEIVING_STATE;
  520. for(i=1;i<argc;i++){
  521. files = tmpfile();
  522. r = getsub(ftp,"NLST",argv[i],files);
  523. if(ftp->abort)
  524. break; /* Aborted */
  525. if(r == -1){
  526. printf("Can't NLST %sn",argv[i]);
  527. continue;
  528. }
  529. /* The tmp file now contains a list of the remote files, so
  530.  * go get 'em. Break out if the user signals an abort.
  531.  */
  532. rewind(files);
  533. while(fgets(buf,DIRBUF,files) != NULL){
  534. rip(buf);
  535. if(!ftp->update || compsub(ftp,buf,buf) != 0){
  536. if((fp = fopen(buf,mode)) == NULL){
  537. printf("Can't write %s",buf);
  538. perror("");
  539. continue;
  540. }
  541. getsub(ftp,"RETR",buf,fp);
  542. fclose(fp);
  543. }
  544. if(ftp->abort){
  545. /* User abort */
  546. ftp->abort = 0;
  547. fclose(files);
  548. free(buf);
  549. ftp->state = COMMAND_STATE;
  550. return 1;
  551. }
  552. }
  553. fclose(files);
  554. }
  555. free(buf);
  556. ftp->state = COMMAND_STATE;
  557. ftp->abort = 0;
  558. return 0;
  559. }
  560. /* List remote directory. Syntax: dir <remote files> [<local name>] */
  561. static int
  562. dolist(argc,argv,p)
  563. int argc;
  564. char *argv[];
  565. void *p;
  566. {
  567. register struct ftpcli *ftp;
  568. FILE *fp;
  570. ftp = (struct ftpcli *)p;
  571. if(ftp == NULL){
  572. printf(Notsess);
  573. return 1;
  574. }
  576. if(argc > 2)
  577. fp = fopen(argv[2],WRITE_TEXT);
  579. else
  580. fp = stdout;
  582. if(fp == NULL){
  583. printf("Can't write local file");
  584. perror("");
  585. return 1;
  586. }
  588. getsub(ftp,"LIST",argv[1],fp);
  589. return 0;
  590. }
  591. /* Remote directory list, short form. Syntax: ls <remote files> [<local name>] */
  592. static int
  593. dols(argc,argv,p)
  594. int argc;
  595. char *argv[];
  596. void *p;
  597. {
  598. register struct ftpcli *ftp;
  599. FILE *fp;
  601. if((ftp = (struct ftpcli *)p) == NULL){
  602. printf(Notsess);
  603. return 1;
  604. }
  605. if(argc > 2)
  606. fp = fopen(argv[2],WRITE_TEXT);
  608. else
  609. fp = stdout;
  611. if(fp == NULL){
  612. printf("Can't write local file");
  613. perror("");
  614. return 1;
  615. }
  616. getsub(ftp,"NLST",argv[1],fp);
  617. return 0;
  618. }
  619. static int
  620. domd5(argc,argv,p)
  621. int argc;
  622. char *argv[];
  623. void *p;
  624. {
  625. char *remotename;
  626. register struct ftpcli *ftp;
  627. FILE *control;
  628. int resp;
  629. int typewait = 0;
  631. ftp = (struct ftpcli *)p;
  632. if(ftp == NULL){
  633. printf(Notsess);
  634. return 1;
  635. }
  636. control = ftp->control;
  637. remotename = argv[1];
  638. if(ftp->typesent != ftp->type){
  639. switch(ftp->type){
  640. case ASCII_TYPE:
  641. fprintf(control,"TYPE An");
  642. break;
  643. case IMAGE_TYPE:
  644. fprintf(control,"TYPE In");
  645. break;
  646. case LOGICAL_TYPE:
  647. fprintf(control,"TYPE L %dn",ftp->logbsize);
  648. break;
  649. }
  650. ftp->typesent = ftp->type;
  651. if(!ftp->batch){
  652. resp = getresp(ftp,200);
  653. if(resp == -1 || resp > 299)
  654. goto failure;
  655. } else
  656. typewait = 1;
  658. }
  659. fprintf(control,"XMD5 %sn",remotename);
  660. if(typewait)
  661. (void)getresp(ftp,200);
  662. (void)getresp(ftp,200);
  663. failure:;
  664. return 0;
  665. }
  666. static int
  667. docompare(argc,argv,p)
  668. int argc;
  669. char *argv[];
  670. void *p;
  671. {
  672. char *remotename,*localname;
  673. register struct ftpcli *ftp;
  675. ftp = (struct ftpcli *)p;
  676. if(ftp == NULL){
  677. printf(Notsess);
  678. return 1;
  679. }
  680. remotename = argv[1];
  681. if(argc > 2)
  682. localname = argv[2];
  683. else
  684. localname = remotename;
  686. if(compsub(ftp,localname,remotename) == 0)
  687. printf("Samen");
  688. else
  689. printf("Differentn");
  690. return 0;
  691. }
  692. /* Compare a collection of files */
  693. static int
  694. domcompare(argc,argv,p)
  695. int argc;
  696. char *argv[];
  697. void *p;
  698. {
  699. register struct ftpcli *ftp;
  700. FILE *files;
  701. char *buf;
  702. int i;
  703. long r;
  705. if((ftp = (struct ftpcli *)p) == NULL){
  706. printf(Notsess);
  707. return 1;
  708. }
  709. buf = mallocw(DIRBUF);
  710. ftp->state = RECEIVING_STATE;
  711. for(i=1;i<argc;i++){
  712. files = tmpfile();
  713. r = getsub(ftp,"NLST",argv[i],files);
  714. if(ftp->abort)
  715. break; /* Aborted */
  716. if(r == -1){
  717. printf("Can't NLST %sn",argv[i]);
  718. continue;
  719. }
  720. /* The tmp file now contains a list of the remote files, so
  721.  * go get 'em. Break out if the user signals an abort.
  722.  */
  723. rewind(files);
  724. while(fgets(buf,DIRBUF,files) != NULL){
  725. rip(buf);
  726. if(compsub(ftp,buf,buf) == 0)
  727. printf("%s - Samen",buf);
  728. else
  729. printf("%s - Differentn",buf);
  731. if(ftp->abort){
  732. /* User abort */
  733. ftp->abort = 0;
  734. fclose(files);
  735. free(buf);
  736. ftp->state = COMMAND_STATE;
  737. return 1;
  738. }
  739. }
  740. fclose(files);
  741. }
  742. free(buf);
  743. ftp->state = COMMAND_STATE;
  744. ftp->abort = 0;
  745. return 0;
  746. }
  747. /* Common subroutine to compare a local with a remote file
  748.  * Return 1 if files are different, 0 if they are the same
  749.  */
  750. static int
  751. compsub(ftp,localname,remotename)
  752. struct ftpcli *ftp;
  753. char *localname;
  754. char *remotename;
  755. {
  756. char *mode,*cp;
  757. FILE *control,*fp;
  758. int resp,i;
  759. int typewait = 0;
  760. uint8 remhash[16];
  761. uint8 lochash[16];
  763. control = ftp->control;
  765. switch(ftp->type){
  766. case IMAGE_TYPE:
  767. case LOGICAL_TYPE:
  768. mode = READ_BINARY;
  769. break;
  770. case ASCII_TYPE:
  771. mode = READ_TEXT;
  772. break;
  773. }
  774. if((fp = fopen(localname,mode)) == NULL){
  775. printf("Can't read local file %sn",localname);
  776. return 1;
  777. }
  778. if(ftp->typesent != ftp->type){
  779. switch(ftp->type){
  780. case ASCII_TYPE:
  781. fprintf(control,"TYPE An");
  782. break;
  783. case IMAGE_TYPE:
  784. fprintf(control,"TYPE In");
  785. break;
  786. case LOGICAL_TYPE:
  787. fprintf(control,"TYPE L %dn",ftp->logbsize);
  788. break;
  789. }
  790. ftp->typesent = ftp->type;
  791. if(!ftp->batch){
  792. resp = getresp(ftp,200);
  793. if(resp == -1 || resp > 299)
  794. goto failure;
  795. } else
  796. typewait = 1;
  797. }
  798. fprintf(control,"XMD5 %sn",remotename);
  799. /* Try to overlap the two MD5 operations */
  800. md5hash(fp,lochash,ftp->type == ASCII_TYPE);
  801. fclose(fp);
  802. if(typewait && (resp = getresp(ftp,200)) > 299)
  803. goto failure;
  804. if((resp = getresp(ftp,200)) > 299){
  805. if(resp == 500)
  806. ftp->update = 0; /* XMD5 not supported */
  807. goto failure;
  808. }
  809. if((cp = strchr(ftp->line,' ')) == NULL){
  810. printf("Error in responsen");
  811. goto failure;
  812. }
  813. /* Convert ascii/hex back to binary */
  814. readhex(remhash,cp,sizeof(remhash));
  815. if(ftp->verbose > 1){
  816. printf("Loc ");
  817. for(i=0;i<sizeof(lochash);i++)
  818. printf("%02x",lochash[i]);
  819. printf(" %sn",localname);
  820. }
  821. if(memcmp(lochash,remhash,sizeof(remhash)) == 0)
  822. return 0;
  823. else
  824. return 1;
  825. failure:;
  826. return 1;
  827. }
  830. /* Common code to LIST/NLST/RETR and mget
  831.  * Returns number of bytes received if successful
  832.  * Returns -1 on error
  833.  */
  834. static long
  835. getsub(ftp,command,remotename,fp)
  836. register struct ftpcli *ftp;
  837. char *command,*remotename;
  838. FILE *fp;
  839. {
  840. unsigned long total;
  841. FILE *control;
  842. int cnt,resp,i,savmode;
  843. struct sockaddr_in lsocket;
  844. struct sockaddr_in lcsocket;
  845. int32 startclk,rate;
  846. int vsave;
  847. int typewait = 0;
  848. int prevstate;
  849. int d;
  851. if(ftp == NULL)
  852. return -1;
  853. savmode = ftp->type;
  854. control = ftp->control;
  856. /* Open the data connection */
  857. d = socket(AF_INET,SOCK_STREAM,0);
  858. listen(d,0); /* Accept only one connection */
  860. switch(ftp->type){
  861. case IMAGE_TYPE:
  862. case LOGICAL_TYPE:
  863. ftp->data = fdopen(d,"r+b");
  864. break;
  865. case ASCII_TYPE:
  866. ftp->data = fdopen(d,"r+t");
  867. break;
  868. }
  869. prevstate = ftp->state;
  870. ftp->state = RECEIVING_STATE;
  872. /* Send TYPE message, if necessary */
  873. if(strcmp(command,"LIST") == 0 || strcmp(command,"NLST") == 0){
  874. /* Directory listings are always in ASCII */
  875. ftp->type = ASCII_TYPE;
  876. }
  877. if(ftp->typesent != ftp->type){
  878. switch(ftp->type){
  879. case ASCII_TYPE:
  880. fprintf(control,"TYPE An");
  881. break;
  882. case IMAGE_TYPE:
  883. fprintf(control,"TYPE In");
  884. break;
  885. case LOGICAL_TYPE:
  886. fprintf(control,"TYPE L %dn",ftp->logbsize);
  887. break;
  888. }
  889. ftp->typesent = ftp->type;
  890. if(!ftp->batch){
  891. resp = getresp(ftp,200);
  892. if(resp == -1 || resp > 299)
  893. goto failure;
  894. } else
  895. typewait = 1;
  896. }
  897. /* Send the PORT message. Use the IP address
  898.  * on the local end of our control connection.
  899.  */
  900. i = SOCKSIZE;
  901. getsockname(d,(struct sockaddr *)&lsocket,&i); /* Get port number */
  902. i = SOCKSIZE;
  903. getsockname(fileno(ftp->control),(struct sockaddr *)&lcsocket,&i);
  904. lsocket.sin_addr.s_addr = lcsocket.sin_addr.s_addr;
  905. sendport(control,&lsocket);
  906. if(!ftp->batch){
  907. /* Get response to PORT command */
  908. resp = getresp(ftp,200);
  909. if(resp == -1 || resp > 299)
  910. goto failure;
  911. }
  913. /* Generate the command to start the transfer */
  914. if(remotename != NULL)
  915. fprintf(control,"%s %sn",command,remotename);
  916. else
  917. fprintf(control,"%sn",command);
  919. if(ftp->batch){
  920. /* Get response to TYPE command, if sent */
  921. if(typewait){
  922. resp = getresp(ftp,200);
  923. if(resp == -1 || resp > 299)
  924. goto failure;
  925. }
  926. /* Get response to PORT command */
  927. resp = getresp(ftp,200);
  928. if(resp == -1 || resp > 299)
  929. goto failure;
  930. }
  931. /* Get the intermediate "150" response */
  932. resp = getresp(ftp,100);
  933. if(resp == -1 || resp >= 400)
  934. goto failure;
  936. /* Wait for the server to open the data connection */
  937. cnt = 0;
  938. d = accept(d,NULL,&cnt);
  939. startclk = msclock();
  941. /* If output is to the screen, temporarily disable hash marking */
  942. vsave = ftp->verbose;
  943. if(vsave >= V_HASH && fp == NULL)
  944. ftp->verbose = V_NORMAL;
  945. total = recvfile(fp,ftp->data,ftp->type,ftp->verbose);
  946. /* Immediately close the data connection; some servers (e.g., TOPS-10)
  947.  * wait for the data connection to close completely before returning
  948.  * the completion message on the control channel
  949.  */
  950. fclose(ftp->data);
  951. ftp->data = NULL;
  953. #ifdef CPM
  954. if(fp != NULL && ftp->type == ASCII_TYPE)
  955. putc(CTLZ,fp);
  956. #endif
  957. if(remotename == NULL)
  958. remotename = "";
  959. if(total == -1){
  960. printf("%s %s: Error/abort during data transfern",command,remotename);
  961. } else if(ftp->verbose >= V_SHORT){
  962. startclk = msclock() - startclk;
  963. rate = 0;
  964. if(startclk != 0){ /* Avoid divide-by-zero */
  965. if(total < 4294967L) {
  966. rate = (total*1000)/startclk;
  967. } else { /* Avoid overflow */
  968. rate = total/(startclk/1000);
  969. }
  970. }
  971. printf("%s %s: %lu bytes in %lu sec (%lu/sec)n",
  972.  command,remotename, total,startclk/1000,rate);
  973. }
  974. /* Get the "Sent" message */
  975. getresp(ftp,200);
  977. ftp->state = prevstate;
  978. ftp->verbose = vsave;
  979. ftp->type = savmode;
  980. return total;
  982. failure:
  983. /* Error, quit */
  984. if(fp != NULL && fp != stdout)
  985. fclose(fp);
  986. fclose(ftp->data);
  987. ftp->data = NULL;
  988. ftp->state = prevstate;
  989. ftp->type = savmode;
  990. return -1;
  991. }
  992. /* Send a file. Syntax: put <local name> [<remote name>] */
  993. static int
  994. doput(argc,argv,p)
  995. int argc;
  996. char *argv[];
  997. void *p;
  998. {
  999. register struct ftpcli *ftp;
  1000. char *remotename,*localname;
  1002. if((ftp = (struct ftpcli *)p) == NULL){
  1003. printf(Notsess);
  1004. return 1;
  1005. }
  1006. localname = argv[1];
  1007. if(argc < 3)
  1008. remotename = localname;
  1009. else
  1010. remotename = argv[2];
  1012. putsub(ftp,remotename,localname);
  1013. return 0;
  1014. }
  1015. /* Put a collection of files */
  1016. static int
  1017. domput(argc,argv,p)
  1018. int argc;
  1019. char *argv[];
  1020. void *p;
  1021. {
  1022. register struct ftpcli *ftp;
  1023. FILE *files;
  1024. int i;
  1025. char *buf;
  1027. if((ftp = (struct ftpcli *)p) == NULL){
  1028. printf(Notsess);
  1029. return 1;
  1030. }
  1031. if((files = tmpfile()) == NULL){
  1032. printf("Can't list local filesn");
  1033. return 1;
  1034. }
  1035. for(i=1;i<argc;i++)
  1036. getdir(argv[i],0,files);
  1038. rewind(files);
  1039. buf = mallocw(DIRBUF);
  1040. ftp->state = SENDING_STATE;
  1041. while(fgets(buf,DIRBUF,files) != NULL){
  1042. rip(buf);
  1043. if(!ftp->update || compsub(ftp,buf,buf) != 0)
  1044. putsub(ftp,buf,buf);
  1045. if(ftp->abort)
  1046. break; /* User abort */
  1047. }
  1048. fclose(files);
  1049. free(buf);
  1050. ftp->state = COMMAND_STATE;
  1051. ftp->abort = 0;
  1052. return 0;
  1053. }
  1054. /* Common code to put, mput.
  1055.  * Returns number of bytes sent if successful
  1056.  * Returns -1 on error
  1057.  */
  1058. static long
  1059. putsub(ftp,remotename,localname)
  1060. register struct ftpcli *ftp;
  1061. char *remotename,*localname;
  1062. {
  1063. char *mode;
  1064. int i,resp,d;
  1065. unsigned long total;
  1066. FILE *fp,*control;
  1067. struct sockaddr_in lsocket,lcsocket;
  1068. int32 startclk,rate;
  1069. int typewait = 0;
  1070. int prevstate;
  1072. control = ftp->control;
  1073. if(ftp->type == IMAGE_TYPE)
  1074. mode = READ_BINARY;
  1075. else
  1076. mode = READ_TEXT;
  1078. /* Open the file */
  1079. if((fp = fopen(localname,mode)) == NULL){
  1080. printf("Can't read %s: %sn",localname,sys_errlist[errno]);
  1081. return -1;
  1082. }
  1083. if(ftp->type == ASCII_TYPE && isbinary(fp)){
  1084. printf("Warning: type is ASCII and %s appears to be binaryn",localname);
  1085. }
  1086. /* Open the data connection */
  1087. d = socket(AF_INET,SOCK_STREAM,0);
  1088. ftp->data = fdopen(d,"w+");
  1089. listen(d,0);
  1090. prevstate = ftp->state;
  1091. ftp->state = SENDING_STATE;
  1093. /* Send TYPE message, if necessary */
  1094. if(ftp->typesent != ftp->type){
  1095. switch(ftp->type){
  1096. case ASCII_TYPE:
  1097. fprintf(control,"TYPE An");
  1098. break;
  1099. case IMAGE_TYPE:
  1100. fprintf(control,"TYPE In");
  1101. break;
  1102. case LOGICAL_TYPE:
  1103. fprintf(control,"TYPE L %dn",ftp->logbsize);
  1104. break;
  1105. }
  1106. ftp->typesent = ftp->type;
  1108. /* Get response to TYPE command */
  1109. if(!ftp->batch){
  1110. resp = getresp(ftp,200);
  1111. if(resp == -1 || resp > 299){
  1112. goto failure;
  1113. }
  1114. } else
  1115. typewait = 1;
  1116. }
  1117. /* Send the PORT message. Use the IP address
  1118.  * on the local end of our control connection.
  1119.  */
  1120. i = SOCKSIZE;
  1121. getsockname(d,(struct sockaddr *)&lsocket,&i);
  1122. i = SOCKSIZE;
  1123. getsockname(fileno(ftp->control),(struct sockaddr *)&lcsocket,&i);
  1124. lsocket.sin_addr.s_addr = lcsocket.sin_addr.s_addr;
  1125. sendport(control,&lsocket);
  1126. if(!ftp->batch){
  1127. /* Get response to PORT command */
  1128. resp = getresp(ftp,200);
  1129. if(resp == -1 || resp > 299){
  1130. goto failure;
  1131. }
  1132. }
  1133. /* Generate the command to start the transfer */
  1134. fprintf(control,"STOR %sn",remotename);
  1136. if(ftp->batch){
  1137. /* Get response to TYPE command, if sent */
  1138. if(typewait){
  1139. resp = getresp(ftp,200);
  1140. if(resp == -1 || resp > 299){
  1141. goto failure;
  1142. }
  1143. }
  1144. /* Get response to PORT command */
  1145. resp = getresp(ftp,200);
  1146. if(resp == -1 || resp > 299){
  1147. goto failure;
  1148. }
  1149. }
  1150. /* Get the intermediate "150" response */
  1151. resp = getresp(ftp,100);
  1152. if(resp == -1 || resp >= 400){
  1153. goto failure;
  1154. }
  1156. /* Wait for the data connection to open. Otherwise the first
  1157.  * block of data would go out with the SYN, and this may confuse
  1158.  * some other TCPs
  1159.  */
  1160. accept(d,NULL,(int *)NULL);
  1162. startclk = msclock();
  1164. total = sendfile(fp,ftp->data,ftp->type,ftp->verbose);
  1165. fflush(ftp->data);
  1166. shutdown(fileno(ftp->data),1); /* Send EOF (FIN) */
  1167. fclose(fp);
  1169. /* Wait for control channel ack before calculating transfer time;
  1170.  * this accounts for transmitted data in the pipe
  1171.  */
  1172. getresp(ftp,200);
  1173. fclose(ftp->data);
  1174. ftp->data = NULL;
  1176. if(total == -1){
  1177. printf("STOR %s: Error/abort during data transfern",remotename);
  1178. } else if(ftp->verbose >= V_SHORT){
  1179. startclk = msclock() - startclk;
  1180. rate = 0;
  1181. if(startclk != 0){ /* Avoid divide-by-zero */
  1182. if(total < 4294967L) {
  1183. rate = (total*1000)/startclk;
  1184. } else { /* Avoid overflow */
  1185. rate = total/(startclk/1000);
  1186. }
  1187. }
  1188. printf("STOR %s: %lu bytes in %lu sec (%lu/sec)n",
  1189.  remotename,total,startclk/1000,rate);
  1190. }
  1191. ftp->state = prevstate;
  1192. return total;
  1194. failure:
  1195. /* Error, quit */
  1196. fclose(fp);
  1197. fclose(ftp->data);
  1198. ftp->data = NULL;
  1199. ftp->state = prevstate;
  1200. return -1;
  1201. }
  1202. /* send PORT message */
  1203. static void
  1204. sendport(fp,socket)
  1205. FILE *fp;
  1206. struct sockaddr_in *socket;
  1207. {
  1208. /* Send PORT a,a,a,a,p,p message */
  1209. fprintf(fp,"PORT %u,%u,%u,%u,%u,%un",
  1210. hibyte(hiword(socket->sin_addr.s_addr)),
  1211. lobyte(hiword(socket->sin_addr.s_addr)),
  1212. hibyte(loword(socket->sin_addr.s_addr)),
  1213. lobyte(loword(socket->sin_addr.s_addr)),
  1214. hibyte(socket->sin_port),
  1215. lobyte(socket->sin_port));
  1216. }
  1218. /* Wait for, read and display response from FTP server. Return the result code.
  1219.  */
  1220. static int
  1221. getresp(ftp,mincode)
  1222. struct ftpcli *ftp;
  1223. int mincode; /* Keep reading until at least this code comes back */
  1224. {
  1225. int rval;
  1227. fflush(ftp->control);
  1228. for(;;){
  1229. /* Get line */
  1230. if(fgets(ftp->line,LINELEN,ftp->control) == NULL){
  1231. rval = -1;
  1232. break;
  1233. }
  1234. rip(ftp->line); /* Remove cr/lf */
  1235. rval = atoi(ftp->line);
  1236. if(rval >= 400 || ftp->verbose >= V_NORMAL)
  1237. printf("%sn",ftp->line); /* Display to user */
  1239. /* Messages with dashes are continued */
  1240. if(ftp->line[3] != '-' && rval >= mincode)
  1241. break;
  1242. }
  1243. return rval;
  1244. }
  1246. /* Issue a prompt and read a line from the user */
  1247. static int
  1248. getline(sp,prompt,buf,n)
  1249. struct session *sp;
  1250. char *prompt;
  1251. char *buf;
  1252. int n;
  1253. {
  1254. printf(prompt);
  1255. fflush(stdout);
  1256. fgets(buf,n,stdin);
  1257. return strlen(buf);
  1258. }
  1259. static int
  1260. keychar(c)
  1261. int c;
  1262. {
  1263. struct ftpcli *ftp;
  1265. if(c != CTLC)
  1266. return 1; /* Ignore all but ^C */
  1268. fprintf(Current->output,"^Cn");
  1269. ftp = Current->cb.ftp;
  1270. switch(ftp->state){
  1271. case COMMAND_STATE:
  1272. alert(Current->proc,EABORT);
  1273. break;
  1274. case SENDING_STATE:
  1275. /* Send a premature EOF.
  1276.  * Unfortunately we can't just reset the connection
  1277.  * since the remote side might end up waiting forever
  1278.  * for us to send something.
  1279.  */
  1280. shutdown(fileno(ftp->data),1); /* Note fall-thru */
  1281. ftp->abort = 1;
  1282. break;
  1283. case RECEIVING_STATE:
  1284. /* Just blow away the receive socket */
  1285. shutdown(fileno(ftp->data),2); /* Note fall-thru */
  1286. ftp->abort = 1;
  1287. break;
  1288. }
  1289. return 0;
  1290. }