octave-jordi: src/DLD-FUNCTIONS/urlwrite.cc comparison

comparison src/DLD-FUNCTIONS/urlwrite.cc @ 10154:40dfc0c99116

DLD-FUNCTIONS/*.cc: untabify

author	John W. Eaton <jwe@octave.org>
date	Wed, 20 Jan 2010 17:33:41 -0500
parents	81e88250bf42
children	4d433bd2d4dc

comparison

equal deleted inserted replaced

-:2c28f9d0360f
+:40dfc0c99116
 {
 public:
 curl_handle_rep (void) : count (1), valid (true), ascii (false)
 {
 curl = curl_easy_init ();
-	if (!curl)
+if (!curl)
-	  error ("can not create curl handle");
+error ("can not create curl handle");
 }
 ~curl_handle_rep (void)
 {
-	if (curl)
+if (curl)
-	  curl_easy_cleanup (curl);
+curl_easy_cleanup (curl);
 }
 bool is_valid (void) const
 {
-	return valid;
+return valid;
 }
 bool perform (bool curlerror) const
 {
-	bool retval = false;
+bool retval = false;
-	if (!error_state)
+if (!error_state)
-	  {
+{
-	    BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	    CURLcode res = curl_easy_perform (curl);
+CURLcode res = curl_easy_perform (curl);
-	    if (res != CURLE_OK)
+if (res != CURLE_OK)
-	      {
+{
-		if (curlerror)
+if (curlerror)
-		  error ("%s", curl_easy_strerror (res));
+error ("%s", curl_easy_strerror (res));
-	      }
+}
-	    else
+else
-	      retval = true;
+retval = true;
-	    END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	  }
+}
-	return retval;
+return retval;
 }
 CURL* handle (void) const
 {
-	return curl;
+return curl;
 }
 bool is_ascii (void) const
 {
-	return ascii;
+return ascii;
 }
 bool is_binary (void) const
 {
-	return !ascii;
+return !ascii;
 }
 size_t count;
 std::string host;
 bool valid;
 {
 rep->valid = false;
 }
 curl_handle (const std::string& _host, const std::string& user,
-	       const std::string& passwd) :
+const std::string& passwd) :
 rep (new curl_handle_rep ())
 {
 rep->host = _host;
 init (user, passwd, std::cin, octave_stdout);
 std::string url = "ftp://" + _host;
 setopt (CURLOPT_URL, url.c_str());
 // Setup the link, with no transfer
 if (!error_state)
-	perform ();
+perform ();
 }
 curl_handle (const std::string& url, const std::string& method,
-	       const Cell& param, std::ostream& os, bool& retval) :
+const Cell& param, std::ostream& os, bool& retval) :
 rep (new curl_handle_rep ())
 {
 retval = false;
 init ("", "", std::cin, os);
 // Don't need to store the parameters here as we can't change
 // the URL after the handle is created
 std::string query_string = form_query_string (param);
 if (method == "get")
-	{
+{
-	  query_string = url + "?" + query_string;
+query_string = url + "?" + query_string;
-	  setopt (CURLOPT_URL, query_string.c_str ());
+setopt (CURLOPT_URL, query_string.c_str ());
-	}
+}
 else if (method == "post")
-	{
+{
-	  setopt (CURLOPT_URL, url.c_str ());
+setopt (CURLOPT_URL, url.c_str ());
-	  setopt (CURLOPT_POSTFIELDS, query_string.c_str ());
+setopt (CURLOPT_POSTFIELDS, query_string.c_str ());
-	}
+}
 else
-	setopt (CURLOPT_URL, url.c_str());
+setopt (CURLOPT_URL, url.c_str());
 if (!error_state)
-	retval = perform (false);
+retval = perform (false);
 }
 curl_handle (const curl_handle& h) : rep (h.rep)
 {
 rep->count++;
 }
 ~curl_handle (void)
 {
 if (--rep->count == 0)
-	delete rep;
+delete rep;
 }
 curl_handle& operator = (const curl_handle& h)
 {
 if (this != &h)
-	{
+{
-	  if (--rep->count == 0)
+if (--rep->count == 0)
-	    delete rep;
+delete rep;
-	  rep = h.rep;
+rep = h.rep;
-	  rep->count++;
+rep->count++;
-	}
+}
 return *this;
 }
 bool is_valid (void) const
 {
 struct curl_slist *slist = 0;
 std::string cmd = "cwd " + path;
 slist = curl_slist_append (slist, cmd.c_str());
 setopt (CURLOPT_POSTQUOTE, slist);
 if (! error_state)
-	perform ();
+perform ();
 setopt (CURLOPT_POSTQUOTE, 0);
 curl_slist_free_all (slist);
 }
 void del (const std::string& file) const
 struct curl_slist *slist = 0;
 std::string cmd = "dele " + file;
 slist = curl_slist_append (slist, cmd.c_str());
 setopt (CURLOPT_POSTQUOTE, slist);
 if (! error_state)
-	perform ();
+perform ();
 setopt (CURLOPT_POSTQUOTE, 0);
 curl_slist_free_all (slist);
 }
 void rmdir (const std::string& path) const
 struct curl_slist *slist = 0;
 std::string cmd = "rmd " + path;
 slist = curl_slist_append (slist, cmd.c_str());
 setopt (CURLOPT_POSTQUOTE, slist);
 if (! error_state)
-	perform ();
+perform ();
 setopt (CURLOPT_POSTQUOTE, 0);
 curl_slist_free_all (slist);
 }
 bool mkdir (const std::string& path, bool curlerror = true) const
 struct curl_slist *slist = 0;
 std::string cmd = "mkd " + path;
 slist = curl_slist_append (slist, cmd.c_str());
 setopt (CURLOPT_POSTQUOTE, slist);
 if (! error_state)
-	retval = perform (curlerror);
+retval = perform (curlerror);
 setopt (CURLOPT_POSTQUOTE, 0);
 curl_slist_free_all (slist);
 return retval;
 }
 slist = curl_slist_append (slist, cmd.c_str());
 cmd = "rnto " + newname;
 slist = curl_slist_append (slist, cmd.c_str());
 setopt (CURLOPT_POSTQUOTE, slist);
 if (! error_state)
-	perform ();
+perform ();
 setopt (CURLOPT_POSTQUOTE, 0);
 curl_slist_free_all (slist);
 }
 void put (const std::string& file, std::istream& is) const
 setopt (CURLOPT_URL, url.c_str());
 setopt (CURLOPT_UPLOAD, 1);
 setopt (CURLOPT_NOBODY, 0);
 set_istream (is);
 if (! error_state)
-	perform ();
+perform ();
 set_istream (std::cin);
 setopt (CURLOPT_NOBODY, 1);
 setopt (CURLOPT_UPLOAD, 0);
 url = "ftp://" + rep->host;
 setopt (CURLOPT_URL, url.c_str());
 std::string url = "ftp://" + rep->host + "/" + file;
 setopt (CURLOPT_URL, url.c_str());
 setopt (CURLOPT_NOBODY, 0);
 set_ostream (os);
 if (! error_state)
-	perform ();
+perform ();
 set_ostream (octave_stdout);
 setopt (CURLOPT_NOBODY, 1);
 url = "ftp://" + rep->host;
 setopt (CURLOPT_URL, url.c_str());
 }
 {
 std::string url = "ftp://" + rep->host + "/";
 setopt (CURLOPT_URL, url.c_str());
 setopt (CURLOPT_NOBODY, 0);
 if (! error_state)
-	perform ();
+perform ();
 setopt (CURLOPT_NOBODY, 1);
 url = "ftp://" + rep->host;
 setopt (CURLOPT_URL, url.c_str());
 }
 setopt (CURLOPT_WRITEDATA, static_cast<void*> (&buf));
 setopt (CURLOPT_URL, url.c_str());
 setopt (CURLOPT_DIRLISTONLY, 1);
 setopt (CURLOPT_NOBODY, 0);
 if (! error_state)
-	perform ();
+perform ();
 setopt (CURLOPT_NOBODY, 1);
 url = "ftp://" + rep->host;
 setopt (CURLOPT_WRITEDATA, static_cast<void*> (&octave_stdout));
 setopt (CURLOPT_DIRLISTONLY, 0);
 setopt (CURLOPT_URL, url.c_str());
 // Count number of directory entries
 std::string str = buf.str ();
 octave_idx_type n = 0;
 size_t pos = 0;
 while (true)
-	{
+{
-	  pos = str.find_first_of('\n', pos);
+pos = str.find_first_of('\n', pos);
-	  if (pos == std::string::npos)
+if (pos == std::string::npos)
-	    break;
+break;
-	  pos++;
+pos++;
-	  n++;
+n++;
-	}
+}
 string_vector retval (n);
 pos = 0;
 for (octave_idx_type i = 0; i < n; i++)
-	{
+{
-	  size_t newpos = str.find_first_of('\n', pos);
+size_t newpos = str.find_first_of('\n', pos);
-	  if (newpos == std::string::npos)
+if (newpos == std::string::npos)
-	    break;
+break;
-	  retval(i) = str.substr(pos, newpos - pos);
+retval(i) = str.substr(pos, newpos - pos);
-	  pos = newpos + 1;
+pos = newpos + 1;
-	}
+}
 return retval;
 }
 void get_fileinfo (const std::string& filename, double& filesize,
-		     time_t& filetime, bool& fileisdir) const
+time_t& filetime, bool& fileisdir) const
 {
 std::string path = pwd();
 std::string url = "ftp://" + rep->host + "/" + path + "/" + filename;
 setopt (CURLOPT_URL, url.c_str());
 // FIXME
 // The MDTM command fails for a directory on the servers I tested
 // so this is a means of testing for directories. It also means
 // I can't get the date of directories!
 if (! error_state)
-	{
+{
-	  if (! perform (false))
+if (! perform (false))
-	    {
+{
-	      fileisdir = true;
+fileisdir = true;
-	      filetime = -1;
+filetime = -1;
-	      filesize = 0;
+filesize = 0;
-	    }
+}
-	  else
+else
-	    {
+{
-	      fileisdir = false;
+fileisdir = false;
-	      time_t ft;
+time_t ft;
-	      curl_easy_getinfo(rep->handle (), CURLINFO_FILETIME, &ft);
+curl_easy_getinfo(rep->handle (), CURLINFO_FILETIME, &ft);
-	      filetime = ft;
+filetime = ft;
-	      double fs;
+double fs;
-	      curl_easy_getinfo(rep->handle (),
+curl_easy_getinfo(rep->handle (),
-				CURLINFO_CONTENT_LENGTH_DOWNLOAD, &fs);
+CURLINFO_CONTENT_LENGTH_DOWNLOAD, &fs);
-	      filesize = fs;
+filesize = fs;
-	    }
+}
-	}
+}
 setopt (CURLOPT_WRITEFUNCTION, write_data);
 setopt (CURLOPT_HEADERFUNCTION, 0);
 setopt (CURLOPT_FILETIME, 0);
 url = "ftp://" + rep->host;
 setopt (CURLOPT_POSTQUOTE, slist);
 setopt (CURLOPT_HEADERFUNCTION, write_data);
 setopt (CURLOPT_WRITEHEADER, static_cast<void *>(&buf));
 if (! error_state)
-	{
+{
-	  perform ();
+perform ();
-	  retval = buf.str();
+retval = buf.str();
-	  // Can I assume that the path is alway in "" on the last line
+// Can I assume that the path is alway in "" on the last line
-	  size_t pos2 = retval.rfind ('"');
+size_t pos2 = retval.rfind ('"');
-	  size_t pos1 = retval.rfind ('"', pos2 - 1);
+size_t pos1 = retval.rfind ('"', pos2 - 1);
-	  retval = retval.substr(pos1 + 1, pos2 - pos1 - 1);
+retval = retval.substr(pos1 + 1, pos2 - pos1 - 1);
-	}
+}
 setopt (CURLOPT_HEADERFUNCTION, 0);
 setopt (CURLOPT_WRITEHEADER, 0);
 setopt (CURLOPT_POSTQUOTE, 0);
 curl_slist_free_all (slist);
 std::string form_query_string (const Cell& param)
 {
 std::ostringstream query;
 for (int i = 0; i < param.numel (); i += 2)
-	{
+{
-	  std::string name = param(i).string_value ();
+std::string name = param(i).string_value ();
-	  std::string text = param(i+1).string_value ();
+std::string text = param(i+1).string_value ();
-	  // Encode strings.
+// Encode strings.
-	  char *enc_name = curl_easy_escape (rep->handle(), name.c_str (),
+char *enc_name = curl_easy_escape (rep->handle(), name.c_str (),
-					     name.length ());
+name.length ());
-	  char *enc_text = curl_easy_escape (rep->handle(), text.c_str (),
+char *enc_text = curl_easy_escape (rep->handle(), text.c_str (),
-					     text.length ());
+text.length ());
-	  query << enc_name << "=" << enc_text;
+query << enc_name << "=" << enc_text;
-	  curl_free (enc_name);
+curl_free (enc_name);
-	  curl_free (enc_text);
+curl_free (enc_text);
-	  if (i < param.numel()-1)
+if (i < param.numel()-1)
-	    query << "&";
+query << "&";
-	}
+}
 query.flush ();
 return query.str ();
 }
 void init (const std::string& user, const std::string& passwd,
-	     std::istream& is, std::ostream& os)
+std::istream& is, std::ostream& os)
 {
 // No data transfer by default
 setopt (CURLOPT_NOBODY, 1);
 // Set the username and password
 std::string userpwd = user;
 if (! passwd.empty ())
-	userpwd += ":" + passwd;
+userpwd += ":" + passwd;
 setopt (CURLOPT_USERPWD, userpwd.c_str ());
 // Define our callback to get called when there's data to be written.
 setopt (CURLOPT_WRITEFUNCTION, write_data);
 ~curl_handles (void)
 {
 // Remove the elements of the map explicitly as they should
 // be deleted before the call to curl_global_cleanup
 for (iterator pa = begin (); pa != end (); pa++)
-	map.erase (pa);
+map.erase (pa);
 curl_global_cleanup ();
 }
 iterator begin (void) { return iterator (map.begin ()); }
 void del (const std::string& k)
 {
 iterator p = map.find (k);
 if (p != map.end ())
-	map.erase (p);
+map.erase (p);
 }
 private:
 std::map<std::string, curl_handle> map;
 };
 error ("urlwrite: method can only be \"get\" or \"post\"");
 return retval;
 }
 if (method != "get" && method != "post")
-	{
+{
-	  error ("urlwrite: method can only be \"get\" or \"post\"");
+error ("urlwrite: method can only be \"get\" or \"post\"");
-	  return retval;
+return retval;
-	}
+}
 param = args(3).cell_value();
 if (error_state)
-	{
+{
-	  error ("urlwrite: parameters for get and post requests must be given as a cell");
+error ("urlwrite: parameters for get and post requests must be given as a cell");
-	  return retval;
+return retval;
-	}
+}
 if (param.numel () % 2 == 1 )
-	{
+{
-	  error ("urlwrite: number of elements in param must be even");
+error ("urlwrite: number of elements in param must be even");
-	  return retval;
+return retval;
-	}
+}
 }
 // The file should only be deleted if it doesn't initially exist, we
 // create it, and the download fails.  We use unwind_protect to do
 // it so that the deletion happens no matter how we exit the function.
 frame.run ();
 if (nargout > 0)
 {
 if (res)
-	{
+{
-	  retval(2) = std::string ();
+retval(2) = std::string ();
-	  retval(1) = true;
+retval(1) = true;
-	  retval(0) = octave_env::make_absolute (filename, octave_env::getcwd ());
+retval(0) = octave_env::make_absolute (filename, octave_env::getcwd ());
-	}
+}
 else
-	{
+{
-	  retval(2) = curl.lasterror ();
+retval(2) = curl.lasterror ();
-	  retval(1) = false;
+retval(1) = false;
-	  retval(0) = std::string ();
+retval(0) = std::string ();
-	}
+}
 }
 if (nargout < 2 && res)
 error ("urlwrite: curl: %s", curl.lasterror ().c_str ());
 if (nargin == 3)
 {
 method = args(1).string_value();
 if (error_state)
-	{
+{
-	  error ("urlread: method can only be \"get\" or \"post\"");
+error ("urlread: method can only be \"get\" or \"post\"");
-	  return retval;
+return retval;
-	}
+}
 if (method != "get" && method != "post")
-	{
+{
-	  error ("urlread: method can only be \"get\" or \"post\"");
+error ("urlread: method can only be \"get\" or \"post\"");
-	  return retval;
+return retval;
-	}
+}
 param = args(2).cell_value();
 if (error_state)
-	{
+{
-	  error ("urlread: parameters for get and post requests must be given as a cell");
+error ("urlread: parameters for get and post requests must be given as a cell");
-	  return retval;
+return retval;
-	}
+}
 if (param.numel () % 2 == 1 )
-	{
+{
-	  error ("urlread: number of elements in param must be even");
+error ("urlread: number of elements in param must be even");
-	  return retval;
+return retval;
-	}
+}
 }
 std::ostringstream buf;
 bool res;
 {
 handle = args(0).string_value ();
 host = args(1).string_value ();
 if (nargin > 1)
-	user = args(2).string_value ();
+user = args(2).string_value ();
 if (nargin > 2)
-	passwd = args(3).string_value ();
+passwd = args(3).string_value ();
 if (!error_state)
-	{
+{
-	  handles.contents (handle) = curl_handle (host, user, passwd);
+handles.contents (handle) = curl_handle (host, user, passwd);
-	  if (error_state)
+if (error_state)
-	    handles.del (handle);
+handles.del (handle);
-	}
+}
 }
 #else
 error ("__ftp__: not available in this version of Octave");
 #endif
 else
 {
 std::string handle = args(0).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    retval = curl.pwd ();
+retval = curl.pwd ();
-	  else
+else
-	    error ("__ftp_pwd__: invalid ftp handle");
+error ("__ftp_pwd__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_pwd__: not available in this version of Octave");
 #endif
 {
 std::string handle = args(0).string_value ();
 std::string path = "";
 if (nargin > 1)
-	path  = args(1).string_value ();
+path  = args(1).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    curl.cwd (path);
+curl.cwd (path);
-	  else
+else
-	    error ("__ftp_cwd__: invalid ftp handle");
+error ("__ftp_cwd__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_cwd__: not available in this version of Octave");
 #endif
 else
 {
 std::string handle = args(0).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    {
+{
-	      if (nargout == 0)
+if (nargout == 0)
-		curl.dir ();
+curl.dir ();
-	      else
+else
-		{
+{
-		  string_vector sv = curl.list ();
+string_vector sv = curl.list ();
-		  octave_idx_type n = sv.length ();
+octave_idx_type n = sv.length ();
-		  if (n == 0)
+if (n == 0)
-		    {
+{
-		      string_vector flds (5);
+string_vector flds (5);
-		      flds(0) = "name";
+flds(0) = "name";
-		      flds(1) = "date";
+flds(1) = "date";
-		      flds(2) = "bytes";
+flds(2) = "bytes";
-		      flds(3) = "isdir";
+flds(3) = "isdir";
-		      flds(4) = "datenum";
+flds(4) = "datenum";
-		      retval = Octave_map (flds);
+retval = Octave_map (flds);
-		    }
+}
-		  else
+else
-		    {
+{
-		      Octave_map st;
+Octave_map st;
-		      Cell filectime (dim_vector (n, 1));
+Cell filectime (dim_vector (n, 1));
-		      Cell filesize (dim_vector (n, 1));
+Cell filesize (dim_vector (n, 1));
-		      Cell fileisdir (dim_vector (n, 1));
+Cell fileisdir (dim_vector (n, 1));
-		      Cell filedatenum (dim_vector (n, 1));
+Cell filedatenum (dim_vector (n, 1));
-		      st.assign ("name", Cell (sv));
+st.assign ("name", Cell (sv));
-		      for (octave_idx_type i = 0; i < n; i++)
+for (octave_idx_type i = 0; i < n; i++)
-			{
+{
-			  time_t ftime;
+time_t ftime;
-			  bool fisdir;
+bool fisdir;
-			  double fsize;
+double fsize;
-			  curl.get_fileinfo (sv(i), fsize, ftime, fisdir);
+curl.get_fileinfo (sv(i), fsize, ftime, fisdir);
-			  fileisdir (i) = fisdir;
+fileisdir (i) = fisdir;
-			  filectime (i) = ctime (&ftime);
+filectime (i) = ctime (&ftime);
-			  filesize (i) = fsize;
+filesize (i) = fsize;
-			  filedatenum (i) = double (ftime);
+filedatenum (i) = double (ftime);
-			}
+}
-		      st.assign ("date", filectime);
+st.assign ("date", filectime);
-		      st.assign ("bytes", filesize);
+st.assign ("bytes", filesize);
-		      st.assign ("isdir", fileisdir);
+st.assign ("isdir", fileisdir);
-		      st.assign ("datenum", filedatenum);
+st.assign ("datenum", filedatenum);
-		      retval = st;
+retval = st;
-		    }
+}
-		}
+}
-	    }
+}
-	  else
+else
-	    error ("__ftp_dir__: invalid ftp handle");
+error ("__ftp_dir__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_dir__: not available in this version of Octave");
 #endif
 else
 {
 std::string handle = args(0).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    curl.ascii ();
+curl.ascii ();
-	  else
+else
-	    error ("__ftp_ascii__: invalid ftp handle");
+error ("__ftp_ascii__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_ascii__: not available in this version of Octave");
 #endif
 else
 {
 std::string handle = args(0).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    curl.binary ();
+curl.binary ();
-	  else
+else
-	    error ("__ftp_binary__: invalid ftp handle");
+error ("__ftp_binary__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_binary__: not available in this version of Octave");
 #endif
 else
 {
 std::string handle = args(0).string_value ();
 if (!error_state)
-	 handles.del (handle);
+handles.del (handle);
 }
 #else
 error ("__ftp_close__: not available in this version of Octave");
 #endif
 {
 std::string handle = args(0).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    retval = (curl.is_ascii() ? "ascii" : "binary");
+retval = (curl.is_ascii() ? "ascii" : "binary");
-	  else
+else
-	    error ("__ftp_binary__: invalid ftp handle");
+error ("__ftp_binary__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_mode__: not available in this version of Octave");
 #endif
 {
 std::string handle = args(0).string_value ();
 std::string file = args(1).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    curl.del (file);
+curl.del (file);
-	  else
+else
-	    error ("__ftp_delete__: invalid ftp handle");
+error ("__ftp_delete__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_delete__: not available in this version of Octave");
 #endif
 {
 std::string handle = args(0).string_value ();
 std::string dir = args(1).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    curl.rmdir (dir);
+curl.rmdir (dir);
-	  else
+else
-	    error ("__ftp_rmdir__: invalid ftp handle");
+error ("__ftp_rmdir__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_rmdir__: not available in this version of Octave");
 #endif
 {
 std::string handle = args(0).string_value ();
 std::string dir = args(1).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    curl.mkdir (dir);
+curl.mkdir (dir);
-	  else
+else
-	    error ("__ftp_mkdir__: invalid ftp handle");
+error ("__ftp_mkdir__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_mkdir__: not available in this version of Octave");
 #endif
 std::string handle = args(0).string_value ();
 std::string oldname = args(1).string_value ();
 std::string newname = args(2).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    curl.rename (oldname, newname);
+curl.rename (oldname, newname);
-	  else
+else
-	    error ("__ftp_rename__: invalid ftp handle");
+error ("__ftp_rename__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_rename__: not available in this version of Octave");
 #endif
 }
 #ifdef HAVE_CURL
 static string_vector
 mput_directory (const curl_handle& curl, const std::string& base,
-		const std::string& dir)
+const std::string& dir)
 {
 string_vector retval;
 if (! curl.mkdir (dir, false))
 warning ("__ftp_mput__: can not create the remote directory ""%s""",
-	     (base.length() == 0 ? dir : base +
+(base.length() == 0 ? dir : base +
-	      file_ops::dir_sep_str () + dir).c_str ());
+file_ops::dir_sep_str () + dir).c_str ());
 curl.cwd (dir);
 if (! error_state)
 {
 unwind_protect_safe frame;
 frame.add_fcn (reset_path, curl);
 std::string realdir = base.length() == 0 ? dir : base +
-			 file_ops::dir_sep_str () + dir;
+file_ops::dir_sep_str () + dir;
 dir_entry dirlist (realdir);
 if (dirlist)
-	{
+{
-	  string_vector files = dirlist.read ();
+string_vector files = dirlist.read ();
-	  for (octave_idx_type i = 0; i < files.length (); i++)
+for (octave_idx_type i = 0; i < files.length (); i++)
-	    {
+{
-	      std::string file = files (i);
+std::string file = files (i);
-	      if (file == "." || file == "..")
+if (file == "." || file == "..")
-		continue;
+continue;
-	      std::string realfile = realdir + file_ops::dir_sep_str () + file;
+std::string realfile = realdir + file_ops::dir_sep_str () + file;
-	      file_stat fs (realfile);
+file_stat fs (realfile);
-	      if (! fs.exists ())
+if (! fs.exists ())
-		{
+{
-		  error ("__ftp__mput: file ""%s"" does not exist",
+error ("__ftp__mput: file ""%s"" does not exist",
-			 realfile.c_str ());
+realfile.c_str ());
-		  break;
+break;
-		}
+}
-	      if (fs.is_dir ())
+if (fs.is_dir ())
-		{
+{
-		  retval.append (mput_directory (curl, realdir, file));
+retval.append (mput_directory (curl, realdir, file));
-		  if (error_state)
+if (error_state)
-		    break;
+break;
-		}
+}
-	      else
+else
-		{
+{
-		  // FIXME Does ascii mode need to be flagged here?
+// FIXME Does ascii mode need to be flagged here?
-		  std::ifstream ifile (realfile.c_str(), std::ios::in |
+std::ifstream ifile (realfile.c_str(), std::ios::in |
-				       std::ios::binary);
+std::ios::binary);
-		  if (! ifile.is_open ())
+if (! ifile.is_open ())
-		    {
+{
-		      error ("__ftp_mput__: unable to open file ""%s""",
+error ("__ftp_mput__: unable to open file ""%s""",
-			     realfile.c_str ());
+realfile.c_str ());
-		      break;
+break;
-		    }
+}
-		  curl.put (file, ifile);
+curl.put (file, ifile);
-		  ifile.close ();
+ifile.close ();
-		  if (error_state)
+if (error_state)
-		    break;
+break;
-		  retval.append (realfile);
+retval.append (realfile);
-		}
+}
-	    }
+}
-	}
+}
 else
-	error ("__ftp_mput__: can not read the directory ""%s""",
+error ("__ftp_mput__: can not read the directory ""%s""",
-	       realdir.c_str());
+realdir.c_str());
 }
 return retval;
 }
 #endif
 {
 std::string handle = args(0).string_value ();
 std::string pat = args(1).string_value ();
 if (!error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    {
+{
-	      glob_match pattern (file_ops::tilde_expand (pat));
+glob_match pattern (file_ops::tilde_expand (pat));
-	      string_vector files = pattern.glob ();
+string_vector files = pattern.glob ();
-	      for (octave_idx_type i = 0; i < files.length (); i++)
+for (octave_idx_type i = 0; i < files.length (); i++)
-		{
+{
-		  std::string file = files (i);
+std::string file = files (i);
-		  file_stat fs (file);
+file_stat fs (file);
-		  if (! fs.exists ())
+if (! fs.exists ())
-		    {
+{
-		      error ("__ftp__mput: file does not exist");
+error ("__ftp__mput: file does not exist");
-		      break;
+break;
-		    }
+}
-		  if (fs.is_dir ())
+if (fs.is_dir ())
-		    {
+{
-		      retval.append (mput_directory (curl, "", file));
+retval.append (mput_directory (curl, "", file));
-		      if (error_state)
+if (error_state)
-			break;
+break;
-		    }
+}
-		  else
+else
-		    {
+{
-		      // FIXME Does ascii mode need to be flagged here?
+// FIXME Does ascii mode need to be flagged here?
-		      std::ifstream ifile (file.c_str(), std::ios::in |
+std::ifstream ifile (file.c_str(), std::ios::in |
-					   std::ios::binary);
+std::ios::binary);
-		      if (! ifile.is_open ())
+if (! ifile.is_open ())
-			{
+{
-			  error ("__ftp_mput__: unable to open file");
+error ("__ftp_mput__: unable to open file");
-			  break;
+break;
-			}
+}
-		      curl.put (file, ifile);
+curl.put (file, ifile);
-		      ifile.close ();
+ifile.close ();
-		      if (error_state)
+if (error_state)
-			break;
+break;
-		      retval.append (file);
+retval.append (file);
-		    }
+}
-		}
+}
-	    }
+}
-	  else
+else
-	    error ("__ftp_mput__: invalid ftp handle");
+error ("__ftp_mput__: invalid ftp handle");
-	}
+}
 }
 #else
 error ("__ftp_mput__: not available in this version of Octave");
 #endif
 }
 #ifdef HAVE_CURL
 static void
 getallfiles (const curl_handle& curl, const std::string& dir,
-	     const std::string& target)
+const std::string& target)
 {
 std::string sep = file_ops::dir_sep_str ();
 file_stat fs (dir);
 if (!fs || !fs.is_dir ())
 {
 std::string msg;
 int status = file_ops::mkdir (dir, 0777, msg);
 if (status < 0)
-	error ("__ftp_mget__: can't create directory %s%s%s. %s",
+error ("__ftp_mget__: can't create directory %s%s%s. %s",
-	       target.c_str(), sep.c_str(), dir.c_str(), msg.c_str());
+target.c_str(), sep.c_str(), dir.c_str(), msg.c_str());
 }
 if (! error_state)
 {
 curl.cwd (dir);
 if (! error_state)
-	{
+{
 unwind_protect_safe frame;
-	  frame.add_fcn (reset_path, curl);
+frame.add_fcn (reset_path, curl);
 string_vector sv = curl.list ();
-	  for (octave_idx_type i = 0; i < sv.length (); i++)
+for (octave_idx_type i = 0; i < sv.length (); i++)
-	    {
+{
-	      time_t ftime;
+time_t ftime;
-	      bool fisdir;
+bool fisdir;
-	      double fsize;
+double fsize;
-	      curl.get_fileinfo (sv(i), fsize, ftime, fisdir);
+curl.get_fileinfo (sv(i), fsize, ftime, fisdir);
-	      if (fisdir)
+if (fisdir)
-		getallfiles (curl, sv(i), target + dir + sep);
+getallfiles (curl, sv(i), target + dir + sep);
-	      else
+else
-		{
+{
-		  std::string realfile = target + dir + sep + sv(i);
+std::string realfile = target + dir + sep + sv(i);
-		  std::ofstream ofile (realfile.c_str(),
+std::ofstream ofile (realfile.c_str(),
-				       std::ios::out |
+std::ios::out |
-				       std::ios::binary);
+std::ios::binary);
-		  if (! ofile.is_open ())
+if (! ofile.is_open ())
-		    {
+{
-		      error ("__ftp_mget__: unable to open file");
+error ("__ftp_mget__: unable to open file");
-		      break;
+break;
-		    }
+}
 unwind_protect_safe frame2;
-		  frame2.add_fcn (delete_file, realfile);
+frame2.add_fcn (delete_file, realfile);
-		  curl.get (sv(i), ofile);
+curl.get (sv(i), ofile);
-		  ofile.close ();
+ofile.close ();
-		  if (!error_state)
+if (!error_state)
-		    frame2.discard ();
+frame2.discard ();
-		  else
+else
-		    frame2.run ();
+frame2.run ();
-		}
+}
-	      if (error_state)
+if (error_state)
-		break;
+break;
-	    }
+}
-	}
+}
 }
 }
 #endif
 DEFUN_DLD (__ftp_mget__, args, ,
 std::string handle = args(0).string_value ();
 std::string file = args(1).string_value ();
 std::string target;
 if (nargin == 3)
-	target = args(2).string_value () + file_ops::dir_sep_str ();
+target = args(2).string_value () + file_ops::dir_sep_str ();
 if (! error_state)
-	{
+{
-	  const curl_handle curl = handles.contents (handle);
+const curl_handle curl = handles.contents (handle);
-	  if (curl.is_valid ())
+if (curl.is_valid ())
-	    {
+{
-	      string_vector sv = curl.list ();
+string_vector sv = curl.list ();
-	      octave_idx_type n = 0;
+octave_idx_type n = 0;
-	      glob_match pattern (file);
+glob_match pattern (file);
-	      for (octave_idx_type i = 0; i < sv.length (); i++)
+for (octave_idx_type i = 0; i < sv.length (); i++)
-		{
+{
-		  if (pattern.match (sv(i)))
+if (pattern.match (sv(i)))
-		    {
+{
-		      n++;
+n++;
-		      time_t ftime;
+time_t ftime;
-		      bool fisdir;
+bool fisdir;
-		      double fsize;
+double fsize;
-		      curl.get_fileinfo (sv(i), fsize, ftime, fisdir);
+curl.get_fileinfo (sv(i), fsize, ftime, fisdir);
-		      if (fisdir)
+if (fisdir)
-			getallfiles (curl, sv(i), target);
+getallfiles (curl, sv(i), target);
-		      else
+else
-			{
+{
-			  std::ofstream ofile ((target + sv(i)).c_str(),
+std::ofstream ofile ((target + sv(i)).c_str(),
-					       std::ios::out |
+std::ios::out |
-					       std::ios::binary);
+std::ios::binary);
-			  if (! ofile.is_open ())
+if (! ofile.is_open ())
-			    {
+{
-			      error ("__ftp_mget__: unable to open file");
+error ("__ftp_mget__: unable to open file");
-			      break;
+break;
-			    }
+}
 unwind_protect_safe frame;
-			  frame.add_fcn (delete_file, target + sv(i));
+frame.add_fcn (delete_file, target + sv(i));
-			  curl.get (sv(i), ofile);
+curl.get (sv(i), ofile);
-			  ofile.close ();
+ofile.close ();
-			  if (!error_state)
+if (!error_state)
-			    frame.discard ();
+frame.discard ();
-			  else
+else
-			    frame.run ();
+frame.run ();
-			}
+}
-		      if (error_state)
+if (error_state)
-			break;
+break;
-		    }
+}
-		}
+}
-	      if (n == 0)
+if (n == 0)
-		error ("__ftp_mget__: file not found");
+error ("__ftp_mget__: file not found");
-	    }
+}
-	}
+}
 }
 #else
 error ("__ftp_mget__: not available in this version of Octave");
 #endif

Mercurial > hg > octave-jordi

comparison src/DLD-FUNCTIONS/urlwrite.cc @ 10154:40dfc0c99116