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.2
Committed:	Mon Jun 10 14:10:44 2002 UTC (22 years, 5 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Tidy up of files. These are all old things that are not only no longer used but are also probably useless to anyone other than us. This saves checking them out all the time, and makes the "cms/source" tree contain only current stuff. They'll still exist in the attic's though :)
#	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