Indetectables

Código: Seleccionar todo

package webdavreader;

import java.net.*;
import java.io.*;
import java.nio.charset.Charset;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class WebDAVreader {
    public static void main(String[] args) throws MalformedURLException, IOException {
        int p = 0; String c; String u;
        
        while(p == 0) {
            System.out.println("¿Conectar con 'proxy' o 'directamente'?");
            c = cLlegir.dato();
            if("proxy".equals(c)) {
                p = 1;
                System.out.println("Bajo construcción"); 
            } else if("directamente".equals(c)){
                p = 1;
                System.out.println("Introduce la URL (http://www.URL.com/)");
                u = cLlegir.dato();
                if(u != null) {
                    File f;
                    String title = TitleExtractor.getPageTitle(u);
                    f = new File(title+".txt");
                    //if (f.exists()){
                        URL pagina = new URL(u);
                        BufferedReader in = new BufferedReader(new InputStreamReader(pagina.openStream()));
                        String entrada;
                        FileWriter w = new FileWriter(f);
                        BufferedWriter bw = new BufferedWriter(w);
                        PrintWriter wr = new PrintWriter(bw); 
                        while ((entrada = in.readLine()) != null)
                        wr.write(entrada);
                        in.close();
                        wr.close();
                        bw.close();
                        System.out.println("Archivo " +f+" creado");
                  //  }else{
                  //      System.out.println("No se ha podido crear el archivo " +f);
                   // }
                    p = 5;
                 }else{
                    System.out.println("URL mal introducida.");
                    p = 0;
                }
            } else {
                p = 0;
                System.out.println("Error");
            }
        }
        while(p == 5){
            p = 6;
            System.out.println("asdf");
        }
    }
}

Código: Seleccionar todo

package webdavreader;

import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class TitleExtractor {
    /* the CASE_INSENSITIVE flag accounts for
     * sites that use uppercase title tags.
     * the DOTALL flag accounts for sites that have
     * line feeds in the title text */
    private static final Pattern TITLE_TAG =
        Pattern.compile("\\<title>(.*)\\</title>", Pattern.CASE_INSENSITIVE|Pattern.DOTALL);
 
    /**
     * @param url the HTML page
     * @return title text (null if document isn't HTML or lacks a title tag)
     * @throws IOException
     */
    public static String getPageTitle(String url) throws IOException {
        URL u = new URL(url);
        URLConnection conn = u.openConnection();
 
        // ContentType is an inner class defined below
        TitleExtractor.ContentType contentType = getContentTypeHeader(conn);
        if (!contentType.contentType.equals("text/html"))
            return null; // don't continue if not HTML
        else {
            // determine the charset, or use the default
            Charset charset = getCharset(contentType);
            if (charset == null)
                charset = Charset.defaultCharset();
 
            // read the response body, using BufferedReader for performance
            InputStream in = conn.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(in, charset));
            int n = 0, totalRead = 0;
            char[] buf = new char[1024];
            StringBuilder content = new StringBuilder();
 
            // read until EOF or first 8192 characters
            while (totalRead < 8192 && (n = reader.read(buf, 0, buf.length)) != -1) {
                content.append(buf, 0, n);
                totalRead += n;
            }
            reader.close();
 
            // extract the title
            Matcher matcher = TITLE_TAG.matcher(content);
            if (matcher.find()) {
                /* replace any occurrences of whitespace (which may
                 * include line feeds and other uglies) as well
                 * as HTML brackets with a space */
                return matcher.group(1).replaceAll("[\\s\\<>]+", " ").trim();
            }
            else
                return null;
        }
    }
 
    /**
     * Loops through response headers until Content-Type is found.
     * @param conn
     * @return ContentType object representing the value of
     * the Content-Type header
     */
    private static TitleExtractor.ContentType getContentTypeHeader(URLConnection conn) {
        int i = 0;
        boolean moreHeaders = true;
        do {
            String headerName = conn.getHeaderFieldKey(i);
            String headerValue = conn.getHeaderField(i);
            if (headerName != null && headerName.equals("Content-Type"))
                return new TitleExtractor.ContentType(headerValue);
 
            i++;
            moreHeaders = headerName != null || headerValue != null;
        }
        while (moreHeaders);
 
        return null;
    }
 
    private static Charset getCharset(TitleExtractor.ContentType contentType) {
        if (contentType != null && contentType.charsetName != null && Charset.isSupported(contentType.charsetName))
            return Charset.forName(contentType.charsetName);
        else
            return null;
    }
 
    /**
     * Class holds the content type and charset (if present)
     */
    private static final class ContentType {
        private static final Pattern CHARSET_HEADER = Pattern.compile("charset=([-_a-zA-Z0-9]+)", Pattern.CASE_INSENSITIVE|Pattern.DOTALL);
 
        private String contentType;
        private String charsetName;
        private ContentType(String headerValue) {
            if (headerValue == null)
                throw new IllegalArgumentException("ContentType must be constructed with a not-null headerValue");
            int n = headerValue.indexOf(";");
            if (n != -1) {
                contentType = headerValue.substring(0, n);
                Matcher matcher = CHARSET_HEADER.matcher(headerValue);
                if (matcher.find())
                    charsetName = matcher.group(1);
            }
            else
                contentType = headerValue;
        }
    }
}

Código: Seleccionar todo

package webdavreader;
import java.io.*;

public class cLlegir {
    public static String dato(){
        String sdato = "";
        try
        {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader flujoE = new BufferedReader(isr);
            sdato = flujoE.readLine();
        }
        catch(IOException e)
        {
            System.err.println("Error: " + e.getMessage());
        }
        return sdato;
    }
    public static short datoShort(){
        try
        {
            return Short.parseShort(dato());
        }
        catch (NumberFormatException e)
        {
            return Short.MIN_VALUE;
        }
    }
    public static int datoInt(){
        try
        {
            return Integer.parseInt(dato());
        }
        catch (NumberFormatException e)
        {
            return Integer.MIN_VALUE;
        }
    }
    public static long datoLong(){
        try
        {
            return Long.parseLong(dato());
        }
        catch (NumberFormatException e)
        {
            return Long.MIN_VALUE;
        }
    }
    public static float datoFloat(){
        try
        {
            Float f = new Float(dato());
            return f.floatValue();
        }
        catch (NumberFormatException e)
        {
            return Float.NaN;
        }
    }
    public static double datoDouble(){
        try
        {
            Double d = new Double(dato());
            return d.doubleValue();
        }
        catch (NumberFormatException e)
        {
            return Double.NaN;
        }
    }
}