c%2B%2B/socket%2B%2B-1.10/ftp.C

// ftp.h 
// Copyright (C) 1992-1995 Gnanasekaran Swaminathan <gs4t@virginia.edu>
// 
// Permission is granted to use at your own risk and distribute this software
// in source and binary forms provided the above copyright
// notice and this paragraph are preserved on all copies.
// This software is provided "as is" with no express or implied warranty.
//
// Version: 17Oct95 1.10

#include <config.h>

#include <ftp.h>
#include <fstream.h>
#include <Fork.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h> // for sprintf
#include <errno.h>

#if defined (__osf__) && defined (__DECCXX)
   extern "C" {
#    include <netdb.h>
   }
#else 
#  include <netdb.h>
#endif

char reptype [][8] = {
  "A N",
  "A T",
  "A C",
  "E N",
  "E T",
  "E C",
  "I",
  "L "
};

char filestru [][8] = {
  "F",
  "R",
  "P"
};

char transmode [][8] = {
  "S",
  "B",
  "C"
};

// ftpdata waits on a port at the local machine.
// When a connection is made, it receives a file from remote
// host if the ostream o is set, or it sends a file to the remote
// host if the istream i is set.
ftp::replycodea ftp::ftpbuf::ftpdata (int portno, istream* i, ostream* o,
                                      const char* cmd, const char* arg)
{
  sockinetbuf sb (sockbuf::sock_stream, 0);

  if (sb.bind_until_success (portno)) {
    sock_error ("ftpdata: ", "bind_until_success failed");
    exit (1);
  }

  useraddr (sb.localaddr ());
  
  sb.listen (1);

  if (send_cmd (cmd, arg) >= ftp::rca_error)
    return ftp::rca_error;
  
  sockbuf c = sb.accept ();

  if (o) {
    // read data from c and put it in o
    char buf [1024];
    int  rdsz;

    while ((rdsz = c.sys_read (buf, 1024)) != EOF)
      o->write (buf, rdsz);
  } else if (i) {
    // read data from i and send it to c
    char buf [1024];
    int  rdsz;
    streambuf* rb = i->rdbuf ();

    while ((rdsz = rb->xsgetn (buf, 1024)) > 0) {
      int wrsz = c.sys_write (buf, rdsz);
      if (rdsz != wrsz)
        cerr << "write error\n";
    }

    c.close (); // this close is needed. Otherwise, c will not send
                // a response.
  }

  return get_response ();
} 

ftp::replycodea ftp::ftpbuf::get_response ()
     // get all the response that one can get and send all of them to o
{
  // if o is 0, then we trash data.
  int  firstline = 1;
  while (underflow () != EOF) {
    int n = in_avail ();
    if (n < 5)
      continue;

    // data is of this form: 221 repsonse <CRLF> or 221-response <CRLF>
    char* q = gptr ();
    char* p = q;

    // zap upto <CRLF>
    int i = 0;
    for (i = 2; i <= n; i++, p++)
      if (*p == '\r' && *(p+1) == '\n') {
        break;
      }
    if (o)
      o->write (q, i);
    gbump (i);

    if (firstline) {
      strncpy (replycode, q, 3);
      replycode [3] = ' ';
      if (q [3] == ' ')
        break;
      firstline = 0;
    } else if (strncmp (q, replycode, 4) == 0)
      break;
  }  

  return (replycodea) replycode [0];
}

ftp::replycodea ftp::ftpbuf::send_cmd (const char* cmd,
                                       const char* arg)
{
  xsputn (cmd, ::strlen (cmd));
  if (arg) {
    xsputn (" ", 1);
    xsputn (arg, ::strlen (arg));
  }
  xsputn ("\r\n", 2);
  flush_output ();
  
  return get_response ();
}

ftp::ftp (ostream* out)
: ios (0)
{
  ios::init (new ftpbuf (out));
}

ftp::ftpbuf::ftpbuf (ostream* out)
: protocol::protocolbuf (protocol::tcp),
  o (out)
{
  replycode [4] = 0;
}

void ftp::ftpbuf::serve_clients (int portno)
// right now no server ftp class cannot be used as a server
{}

ftp::replycodea ftp::ftpbuf::cd (const char* dir)
{
  return send_cmd ("CWD", dir);
}

ftp::replycodea ftp::ftpbuf::useraddr (sockinetaddr sa)
{
  if (sa.sin_addr.s_addr == 0) {
    // local host
    char hostname [64];
    if (::gethostname (hostname, 63) == -1) {
      perror ("ftpbuf::useraddr");
      return ftp::rca_error;
    }

    hostent* hp = gethostbyname (hostname);
    if (hp == 0) {
      sock_error ("ftpbuf: ", "gethostbyname");
      return ftp::rca_error;
    }

    memcpy (&sa.sin_addr, hp->h_addr, hp->h_length);
  }

  struct in_addr ina = sa.sin_addr;
  int    portno      = ntohs(sa.sin_port);
  char*  ina_p       = inet_ntoa (ina);
  char   addr [80];

  char* p = 0;
  strcpy (addr, ina_p);
  while (p = strchr (addr, '.'))
    *p = ',';

  int hi_portno = portno >> 8;
  int lo_portno = portno & 0xff;

  sprintf (addr + strlen (addr), ",%d,%d", hi_portno, lo_portno);

  return send_cmd ("PORT", addr);
}

ftp::replycodea ftp::ftpbuf::useraddr (const char* hostname, int portno)
{
  return useraddr (sockinetaddr (hostname, portno));
}

ftp::replycodea ftp::ftpbuf::server_port (int portno)
{
  int hi_portno = portno >> 8;
  int lo_portno = portno & 0xff;
  char port [80];
  
  sprintf (port, "%d,%d", hi_portno, lo_portno);
  
  return send_cmd ("PASV", port);
}
  
ftp::replycodea ftp::ftpbuf::rep_type (ftp::reptype rt)
{
  return send_cmd ("TYPE", ::reptype [int(rt)]);
}

ftp::replycodea ftp::ftpbuf::file_stru (ftp::filestru fs)
{
  return send_cmd ("STRU", ::filestru [int(fs)]);
}

ftp::replycodea ftp::ftpbuf::trans_mode (ftp::transmode tm)
{
  return send_cmd ("STRU", ::transmode [int(tm)]);
}

ftp::replycodea ftp::ftpbuf::getfile (const char* rpath, const char* lpath)
{
  if (lpath == 0)
    lpath = rpath;

  if (rpath == 0)
    list ();

  ofstream f (lpath);
  return ftpdata (10000, 0, &f, "RETR", rpath);
}

ftp::replycodea ftp::ftpbuf::list (const char* rpath, int justnames)
{
  if (justnames)
    return ftpdata (10000, 0, o, "NLST", rpath);
  else
    return ftpdata (10000, 0, o, "LIST", rpath);
}

ftp::replycodea ftp::ftpbuf::putfile (const char* lpath, const char* rpath)
{
  if (rpath == 0)
    rpath = lpath;

  if (lpath == 0)
    return ftp::rca_error;

  ifstream f(lpath);
  return ftpdata (10000, &f, 0, "STOR", rpath);
}

ftp::replycodea ftp::ftpbuf::putfile (const char* lpath)
{
  if (lpath == 0)
    return ftp::rca_error;

  ifstream f(lpath);
  return ftpdata (10000, &f, 0, "STOU", lpath);
}
  
ftp::replycodea ftp::ftpbuf::append  (const char* lpath, const char* rpath)
{
  if (lpath == 0)
    return ftp::rca_error;

  if (rpath == 0)
    rpath = lpath;

  ifstream f(lpath);
  return ftpdata (10000, &f, 0, "APPE", 0);
}

ftp::replycodea ftp::ftpbuf::allocate (int numbytes)
{
  char b[32];
  sprintf (b, "%d", numbytes);
  return send_cmd ("ALLO", b);
}

ftp::replycodea ftp::ftpbuf::restart (int marker)
{
  char b[32];
  sprintf (b, "%d", marker);
  return send_cmd ("REST", b);
}

ftp::replycodea ftp::ftpbuf::rename (const char* rpath, const char* newrpath)
{
  if (rpath == 0 || newrpath == 0)
    return ftp::rca_error;

  if (send_cmd ("RNFR", rpath) >= ftp::rca_error)
    return rca_error;

  return send_cmd ("RNTO", newrpath);
}

ftp::replycodea ftp::ftpbuf::rmfile (const char* rpath)
{
  return send_cmd ("DELE", rpath);
}

ftp::replycodea ftp::ftpbuf::rmdir  (const char* rpath)
{
  return send_cmd ("RMD", rpath);
}

ftp::replycodea ftp::ftpbuf::mkdir  (const char* rpath)
{
  return send_cmd ("MKD", rpath);
}

Revision:	1.1
Committed:	Mon Feb 26 15:01:39 2001 UTC (23 years, 6 months ago) by ab11
Content type:	text/plain
Branch:	MAIN
CVS Tags:	PROJECT_COMPLETION
Log Message:	Networking class. Assumed to be bug free.
#	User	Rev	Content
1	ab11	1.1	// ftp.h
2			// Copyright (C) 1992-1995 Gnanasekaran Swaminathan <gs4t@virginia.edu>
3			//
4			// Permission is granted to use at your own risk and distribute this software
5			// in source and binary forms provided the above copyright
6			// notice and this paragraph are preserved on all copies.
7			// This software is provided "as is" with no express or implied warranty.
8			//
9			// Version: 17Oct95 1.10
10
11			#include <config.h>
12
13			#include <ftp.h>
14			#include <fstream.h>
15			#include <Fork.h>
16			#include <fcntl.h>
17			#include <unistd.h>
18			#include <stdlib.h>
19			#include <string.h>
20			#include <stdio.h> // for sprintf
21			#include <errno.h>
22
23			#if defined (__osf__) && defined (__DECCXX)
24			extern "C" {
25			# include <netdb.h>
26			}
27			#else
28			# include <netdb.h>
29			#endif
30
31			char reptype [][8] = {
32			"A N",
33			"A T",
34			"A C",
35			"E N",
36			"E T",
37			"E C",
38			"I",
39			"L "
40			};
41
42			char filestru [][8] = {
43			"F",
44			"R",
45			"P"
46			};
47
48			char transmode [][8] = {
49			"S",
50			"B",
51			"C"
52			};
53
54			// ftpdata waits on a port at the local machine.
55			// When a connection is made, it receives a file from remote
56			// host if the ostream o is set, or it sends a file to the remote
57			// host if the istream i is set.
58			ftp::replycodea ftp::ftpbuf::ftpdata (int portno, istream* i, ostream* o,
59			const char* cmd, const char* arg)
60			{
61			sockinetbuf sb (sockbuf::sock_stream, 0);
62
63			if (sb.bind_until_success (portno)) {
64			sock_error ("ftpdata: ", "bind_until_success failed");
65			exit (1);
66			}
67
68			useraddr (sb.localaddr ());
69
70			sb.listen (1);
71
72			if (send_cmd (cmd, arg) >= ftp::rca_error)
73			return ftp::rca_error;
74
75			sockbuf c = sb.accept ();
76
77			if (o) {
78			// read data from c and put it in o
79			char buf [1024];
80			int rdsz;
81
82			while ((rdsz = c.sys_read (buf, 1024)) != EOF)
83			o->write (buf, rdsz);
84			} else if (i) {
85			// read data from i and send it to c
86			char buf [1024];
87			int rdsz;
88			streambuf* rb = i->rdbuf ();
89
90			while ((rdsz = rb->xsgetn (buf, 1024)) > 0) {
91			int wrsz = c.sys_write (buf, rdsz);
92			if (rdsz != wrsz)
93			cerr << "write error\n";
94			}
95
96			c.close (); // this close is needed. Otherwise, c will not send
97			// a response.
98			}
99
100			return get_response ();
101			}
102
103			ftp::replycodea ftp::ftpbuf::get_response ()
104			// get all the response that one can get and send all of them to o
105			{
106			// if o is 0, then we trash data.
107			int firstline = 1;
108			while (underflow () != EOF) {
109			int n = in_avail ();
110			if (n < 5)
111			continue;
112
113			// data is of this form: 221 repsonse <CRLF> or 221-response <CRLF>
114			char* q = gptr ();
115			char* p = q;
116
117			// zap upto <CRLF>
118			int i = 0;
119			for (i = 2; i <= n; i++, p++)
120			if (p == '\r' && (p+1) == '\n') {
121			break;
122			}
123			if (o)
124			o->write (q, i);
125			gbump (i);
126
127			if (firstline) {
128			strncpy (replycode, q, 3);
129			replycode [3] = ' ';
130			if (q [3] == ' ')
131			break;
132			firstline = 0;
133			} else if (strncmp (q, replycode, 4) == 0)
134			break;
135			}
136
137			return (replycodea) replycode [0];
138			}
139
140			ftp::replycodea ftp::ftpbuf::send_cmd (const char* cmd,
141			const char* arg)
142			{
143			xsputn (cmd, ::strlen (cmd));
144			if (arg) {
145			xsputn (" ", 1);
146			xsputn (arg, ::strlen (arg));
147			}
148			xsputn ("\r\n", 2);
149			flush_output ();
150
151			return get_response ();
152			}
153
154			ftp::ftp (ostream* out)
155			: ios (0)
156			{
157			ios::init (new ftpbuf (out));
158			}
159
160			ftp::ftpbuf::ftpbuf (ostream* out)
161			: protocol::protocolbuf (protocol::tcp),
162			o (out)
163			{
164			replycode [4] = 0;
165			}
166
167			void ftp::ftpbuf::serve_clients (int portno)
168			// right now no server ftp class cannot be used as a server
169			{}
170
171			ftp::replycodea ftp::ftpbuf::cd (const char* dir)
172			{
173			return send_cmd ("CWD", dir);
174			}
175
176			ftp::replycodea ftp::ftpbuf::useraddr (sockinetaddr sa)
177			{
178			if (sa.sin_addr.s_addr == 0) {
179			// local host
180			char hostname [64];
181			if (::gethostname (hostname, 63) == -1) {
182			perror ("ftpbuf::useraddr");
183			return ftp::rca_error;
184			}
185
186			hostent* hp = gethostbyname (hostname);
187			if (hp == 0) {
188			sock_error ("ftpbuf: ", "gethostbyname");
189			return ftp::rca_error;
190			}
191
192			memcpy (&sa.sin_addr, hp->h_addr, hp->h_length);
193			}
194
195			struct in_addr ina = sa.sin_addr;
196			int portno = ntohs(sa.sin_port);
197			char* ina_p = inet_ntoa (ina);
198			char addr [80];
199
200			char* p = 0;
201			strcpy (addr, ina_p);
202			while (p = strchr (addr, '.'))
203			*p = ',';
204
205			int hi_portno = portno >> 8;
206			int lo_portno = portno & 0xff;
207
208			sprintf (addr + strlen (addr), ",%d,%d", hi_portno, lo_portno);
209
210			return send_cmd ("PORT", addr);
211			}
212
213			ftp::replycodea ftp::ftpbuf::useraddr (const char* hostname, int portno)
214			{
215			return useraddr (sockinetaddr (hostname, portno));
216			}
217
218			ftp::replycodea ftp::ftpbuf::server_port (int portno)
219			{
220			int hi_portno = portno >> 8;
221			int lo_portno = portno & 0xff;
222			char port [80];
223
224			sprintf (port, "%d,%d", hi_portno, lo_portno);
225
226			return send_cmd ("PASV", port);
227			}
228
229			ftp::replycodea ftp::ftpbuf::rep_type (ftp::reptype rt)
230			{
231			return send_cmd ("TYPE", ::reptype [int(rt)]);
232			}
233
234			ftp::replycodea ftp::ftpbuf::file_stru (ftp::filestru fs)
235			{
236			return send_cmd ("STRU", ::filestru [int(fs)]);
237			}
238
239			ftp::replycodea ftp::ftpbuf::trans_mode (ftp::transmode tm)
240			{
241			return send_cmd ("STRU", ::transmode [int(tm)]);
242			}
243
244			ftp::replycodea ftp::ftpbuf::getfile (const char* rpath, const char* lpath)
245			{
246			if (lpath == 0)
247			lpath = rpath;
248
249			if (rpath == 0)
250			list ();
251
252			ofstream f (lpath);
253			return ftpdata (10000, 0, &f, "RETR", rpath);
254			}
255
256			ftp::replycodea ftp::ftpbuf::list (const char* rpath, int justnames)
257			{
258			if (justnames)
259			return ftpdata (10000, 0, o, "NLST", rpath);
260			else
261			return ftpdata (10000, 0, o, "LIST", rpath);
262			}
263
264			ftp::replycodea ftp::ftpbuf::putfile (const char* lpath, const char* rpath)
265			{
266			if (rpath == 0)
267			rpath = lpath;
268
269			if (lpath == 0)
270			return ftp::rca_error;
271
272			ifstream f(lpath);
273			return ftpdata (10000, &f, 0, "STOR", rpath);
274			}
275
276			ftp::replycodea ftp::ftpbuf::putfile (const char* lpath)
277			{
278			if (lpath == 0)
279			return ftp::rca_error;
280
281			ifstream f(lpath);
282			return ftpdata (10000, &f, 0, "STOU", lpath);
283			}
284
285			ftp::replycodea ftp::ftpbuf::append (const char* lpath, const char* rpath)
286			{
287			if (lpath == 0)
288			return ftp::rca_error;
289
290			if (rpath == 0)
291			rpath = lpath;
292
293			ifstream f(lpath);
294			return ftpdata (10000, &f, 0, "APPE", 0);
295			}
296
297			ftp::replycodea ftp::ftpbuf::allocate (int numbytes)
298			{
299			char b[32];
300			sprintf (b, "%d", numbytes);
301			return send_cmd ("ALLO", b);
302			}
303
304			ftp::replycodea ftp::ftpbuf::restart (int marker)
305			{
306			char b[32];
307			sprintf (b, "%d", marker);
308			return send_cmd ("REST", b);
309			}
310
311			ftp::replycodea ftp::ftpbuf::rename (const char* rpath, const char* newrpath)
312			{
313			if (rpath == 0 \|\| newrpath == 0)
314			return ftp::rca_error;
315
316			if (send_cmd ("RNFR", rpath) >= ftp::rca_error)
317			return rca_error;
318
319			return send_cmd ("RNTO", newrpath);
320			}
321
322			ftp::replycodea ftp::ftpbuf::rmfile (const char* rpath)
323			{
324			return send_cmd ("DELE", rpath);
325			}
326
327			ftp::replycodea ftp::ftpbuf::rmdir (const char* rpath)
328			{
329			return send_cmd ("RMD", rpath);
330			}
331
332			ftp::replycodea ftp::ftpbuf::mkdir (const char* rpath)
333			{
334			return send_cmd ("MKD", rpath);
335			}
336