[java] Email adres parsen

[Nappa]

Ik heb in een String email het wannabe-email adres. Nu wil ik nagaan of dit wel een valid email adres is, daarvoor gebruik ik de volgende code:

code:

import javax.mail.internet.*

(knip)
   InternetAddress address = null;
    try {
    address = new InternetAddress(email);
    } catch ( AddressException e ) {
      // invalid email address
    }

Dit zou toch een exception moeten geven wanneer het email adres niet geldig is? Dat doet ie echter niet
Of geeft de constructor van InternetAddress pas onder andere omstandigheden een exception?
Is dit op te lossen of moet ik zelf een parsertje schrijven??

[Uiligheid]

volgens mij moet hij dan een exception geven. Maar ik weet niet of je de juiste exception aan het catchen bent... Staat toch ook wel in de API ?

[Uiligheid]

moet het niet zijn:

code:

catch (InternetAddress exception e)
{
bla..
}

[Verwijderd]

Op dinsdag 11 juni 2002 15:58 schreef Uiligheid het volgende:
moet het niet zijn:

code:

catch (InternetAddress exception e)
{
bla..
}

Een ding weet ik zeker, en dat is dat dit iig niet goed is...

[Glimi]

1 ding is nog zekerder. Je catched de execption, dus laten zien zal ie niet.
Wel de code tussen je exception block uitvoeren

[Nappa]

Op dinsdag 11 juni 2002 15:58 schreef Uiligheid het volgende:

moet het niet zijn:

code:

catch (InternetAddress exception e)

{

bla..

}

Nee, in de API staat dat de constructor een AddressException throwt.

Ik heb ondertussen al heel wat afgekloot maar ik denk dat ik dan maar iets anders ga proberen, als ik zelf even n parsertje schrijf gaat het denk ik sneller!
Volgens mij is het gewoon niet geschikt ofzo voor mijn bedoelingen, of weet iemand het misschien nog?

[Nappa]

Op dinsdag 11 juni 2002 16:15 schreef Glimi het volgende:

1 ding is nog zekerder. Je catched de execption, dus laten zien zal ie niet.

Wel de code tussen je exception block uitvoeren

Doe k wel hoor (had hier alleen weggeknipt voor de overzichtelijkheid )

[Uiligheid]

wat ik iig ooit gehad heb, is dat dat kreng wel valideert, kan ook met URL's..

Maar ja, das een stoffig verleden..

[mbravenboer]

Hij zou inderdaad een exception moet gooien als het adres syntaxtisch gezien incorrect is. Uiteraard wordt er niet gecontroleerd of het adres ook daadwerkelijk bestaat.

Het kan in dergelijke gevallen geen kwaad om even de source te bekijken om te zien wat er gebeurd. In dit geval wordt er een uitermate ranzige parse methode aangeroepen die ik voor het amusement maar even hier neer zet:

code:

    public static InternetAddress[] parse(String s, boolean flag)
      throws AddressException
    {
      int i1 = -1;
      int j1 = -1;
      int k1 = s.length();
      boolean flag1 = false;
      boolean flag2 = false;
      boolean flag3 = false;
      Vector vector = new Vector();
      int j;
      int i = j = -1;
      int k;
      for(k = 0; k < k1; k++)
      {
        char c = s.charAt(k);
        switch(c)
        {
        case 9: // '\t'
        case 10: // '\n'
        case 13: // '\r'
        case 32: // ' '
            break;

        case 40: // '('
            flag3 = true;
            if(i >= 0 && j == -1)
              j = k;
            if(i1 == -1)
              i1 = k + 1;
            k++;
            int l;
            for(l = 1; k < k1 && l > 0; k++)
            {
              char c1 = s.charAt(k);
              switch(c1)
              {
              case 92: // '\\'
                k++;
                break;

              case 40: // '('
                l++;
                break;

              case 41: // ')'
                l--;
                break;
              }
            }

            if(l > 0)
              throw new AddressException("Missing ')'", s, k);
            k--;
            if(j1 == -1)
              j1 = k;
            break;

        case 41: // ')'
            throw new AddressException("Missing '('", s, k);

        case 60: // '<'
            flag3 = true;
            if(flag2)
              throw new AddressException("Extra route-addr", s, k);
            if(!flag1)
            {
              i1 = i;
              if(i1 >= 0)
                j1 = k;
              i = k + 1;
            }
            boolean flag4 = false;
label0:
            for(k++; k < k1; k++)
            {
              char c2 = s.charAt(k);
              switch(c2)
              {
              default:
                break;

              case 92: // '\\'
                k++;
                break;

              case 34: // '"'
                flag4 = !flag4;
                break;

              case 62: // '>'
                if(!flag4)
                    break label0;
                break;
              }
            }

            if(k >= k1)
              if(flag4)
                throw new AddressException("Missing '\"'", s, k);
              else
                throw new AddressException("Missing '>'", s, k);
            flag2 = true;
            j = k;
            break;

        case 62: // '>'
            throw new AddressException("Missing '<'", s, k);

        case 34: // '"'
            flag3 = true;
            if(i == -1)
              i = k;
label1:
            for(k++; k < k1;)
            {
              char c3 = s.charAt(k);
              switch(c3)
              {
              case 34: // '"'
                break label1;

              case 92: // '\\'
                k++;
                // fall through

              default:
                k++;
                break;
              }
            }

            if(k >= k1)
              throw new AddressException("Missing '\"'", s, k);
            break;

        case 91: // '['
            flag3 = true;
label2:
            for(k++; k < k1;)
            {
              char c4 = s.charAt(k);
              switch(c4)
              {
              case 93: // ']'
                break label2;

              case 92: // '\\'
                k++;
                // fall through

              default:
                k++;
                break;
              }
            }

            if(k >= k1)
              throw new AddressException("Missing ']'", s, k);
            break;

        case 44: // ','
            if(i == -1)
            {
              flag2 = false;
              flag3 = false;
              i = j = -1;
              break;
            }
            if(flag1)
              break;
            if(j == -1)
              j = k;
            String s2 = s.substring(i, j).trim();
            if(flag3 || flag)
            {
              checkAddress(s2, flag2, flag);
              InternetAddress internetaddress = new InternetAddress();
              internetaddress.setAddress(s2);
              if(i1 >= 0)
              {
                internetaddress.encodedPersonal = unquote(s.substring(i1, j1).trim());
                i1 = j1 = -1;
              }
              vector.addElement(internetaddress);
            } else
            {
              InternetAddress internetaddress1;
              for(StringTokenizer stringtokenizer1 = new StringTokenizer(s2); stringtokenizer1.hasMoreTokens(); vector.addElement(internetaddress1))
              {
                String s4 = stringtokenizer1.nextToken();
                checkAddress(s4, false, flag);
                internetaddress1 = new InternetAddress();
                internetaddress1.setAddress(s4);
              }

            }
            flag2 = false;
            flag3 = false;
            i = j = -1;
            break;

        case 58: // ':'
            flag3 = true;
            if(flag1)
              throw new AddressException("Nested group", s, k);
            flag1 = true;
            break;

        case 59: // ';'
            if(!flag1)
              throw new AddressException("Illegal semicolon, not in group", s, k);
            flag1 = false;
            InternetAddress internetaddress2 = new InternetAddress();
            j = k + 1;
            internetaddress2.setAddress(s.substring(i, j).trim());
            vector.addElement(internetaddress2);
            flag2 = false;
            i = j = -1;
            break;

        default:
            if(i == -1)
              i = k;
            break;
        }
      }

      if(i >= 0)
      {
        if(j == -1)
            j = k;
        String s1 = s.substring(i, j).trim();
        if(flag3 || flag)
        {
            checkAddress(s1, flag2, flag);
            InternetAddress internetaddress3 = new InternetAddress();
            internetaddress3.setAddress(s1);
            if(i1 >= 0)
              internetaddress3.encodedPersonal = unquote(s.substring(i1, j1).trim());
            vector.addElement(internetaddress3);
        } else
        {
            InternetAddress internetaddress4;
            for(StringTokenizer stringtokenizer = new StringTokenizer(s1); stringtokenizer.hasMoreTokens(); vector.addElement(internetaddress4))
            {
              String s3 = stringtokenizer.nextToken();
              checkAddress(s3, false, flag);
              internetaddress4 = new InternetAddress();
              internetaddress4.setAddress(s3);
            }

        }
      }
      InternetAddress ainternetaddress[] = new InternetAddress[vector.size()];
      vector.copyInto(ainternetaddress);
      return ainternetaddress;
    }

Je kan even kijken of het adres waar hij niet op faalt door deze parse methode komt en waarom. Kijk allereerst eens goed of het adres inderdaad wel incorrect is.

Als je een betere parser nodig blijkt te hebben zou ik even een regex pakken (zat vinden hier op GoT) en de nieuwe regex library in 1.4 gebruiken om het email adres te controleren.

[mbravenboer]

btw: die variabele namen komen door jad, waarschijnlijk is de echte source net iets duidelijker . Je kan de source ook downloaden als de SCSL ondertekend.

Als er nog mensen opmerkingen maken over mijn reverse-engineering praktijken in dit topic: ter referentie vind ik dat dit een goed middel is als de API documentatie niet voldoet: hadden ze die maar beter moeten maken .

Helaas zit JavaMail niet in de standaard J2SDK, waardoor de source niet daarin is opgenomen.

[Bobco]

Al je alleen wilt parsen, dan kun je natuurlijk ook gewoon

code:

InternetAddress.parse(email, true);

gebruiken. Weet iemand of die constructor standaard lenient of strict parsed?