├── .gitignore
├── config.json
├── examples
    └── example.js
├── package.json
├── lib
    ├── dnscheck.js
    ├── detect.js
    ├── guess.js
    └── autoconfig.js
├── README.md
└── index.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | .DS_Store
3 | 


--------------------------------------------------------------------------------
/config.json:
--------------------------------------------------------------------------------
1 | {
2 |     "disableCache": false,
3 |     "redis": {
4 |         "host": "localhost",
5 |         "port": false,
6 |         "db": 4
7 |     },
8 |     "cacheExpire": 86400
9 | }


--------------------------------------------------------------------------------
/examples/example.js:
--------------------------------------------------------------------------------
1 | var autoconfig = require("../index");
2 | 
3 | var detector = autoconfig.createIMAPSettingsDetector();
4 | 
5 | detector.detect("pipemail@node.ee", "zzzzz", true, function(err, data){
6 |     console.log(err || data);
7 | });
8 | 
9 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "imap-autoconfig",
 3 |   "version": "0.1.5",
 4 |   "description": "Detect IMAP configuration for an e-mail address",
 5 |   "author" : "Andris Reinman",
 6 |   "main": "index.js",
 7 |   "scripts": {
 8 |     "test": "echo \"Error: no test specified\" && exit 1"
 9 |   },
10 |   "license": "MIT",
11 |   "dependencies": {
12 |     "fetch": "*",
13 |     "xml2object": "git://github.com/andris9/node-xml2object.git",
14 |     "inbox": "*",
15 |     "redis": "*"
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/lib/dnscheck.js:
--------------------------------------------------------------------------------
 1 | var dns = require('dns');
 2 | 
 3 | // http://tools.ietf.org/html/rfc6186
 4 | 
 5 | module.exports.detectIMAPConnectionSettings = detectIMAPConnectionSettings;
 6 | 
 7 | function detectIMAPConnectionSettings(address, password, callback){
 8 |     if(!callback && typeof password == "function"){
 9 |         callback = password;
10 |         password = undefined;
11 |     }
12 | 
13 |     var parts = (address || "").toString().split("@"),
14 |         user = parts.shift() || "",
15 |         domain = parts.pop() || "";
16 | 
17 |     if(!user || !domain){
18 |         return callback(new Error("Data missing"));
19 |     }
20 | 
21 |     var protos = ["imap", "imaps"],
22 |         waitingFor = protos.length,
23 |         ready = false;
24 | 
25 |     for(var i=0, len = protos.length; i<len; i++){
26 |         checkProtocol(protos[i], domain, function(err, data){
27 |             waitingFor--;
28 | 
29 |             if(ready){
30 |                 return;
31 |             }
32 |             
33 |             if(data){
34 |                 ready = true;
35 |                 return callback(null, data);
36 |             }
37 | 
38 |             if(waitingFor == 0){
39 |                 return callback(null, null);
40 |             }
41 |         });
42 |     }
43 | }
44 | 
45 | function checkProtocol(proto, domain, callback){
46 |     dns.resolve("_"+proto+"._tcp."+domain, "SRV", function(err, addresses){
47 |         var data = {};
48 | 
49 |         if(err){
50 |             return callback(err);
51 |         }
52 |         if(!addresses || !addresses.length || !addresses[0].name || addresses[0].name == "."){
53 |             return callback(null, null);
54 |         }
55 | 
56 |         if(proto == "imaps"){
57 |             data.host = addresses[0].name;
58 |             data.port = addresses[0].port;
59 |             data.secure = proto == "imaps";
60 |         }
61 | 
62 |         callback(null, data);
63 |     })
64 | }
65 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # IMAP AutoConfig
 2 | 
 3 | Detect e-mail connection settings
 4 | 
 5 | ## Usage
 6 | 
 7 | Require imap-autoconfig
 8 | 
 9 |     var autoconfig = require("imap-autoconfig");
10 | 
11 | ### Autoconfig object
12 | 
13 | Create new autoconfig object
14 | 
15 |     var detector = autoconfig.createIMAPSettingsDetector(config);
16 | 
17 | Where config is an optional (if not set, predefined values will be used) 
18 | configuration object with following properties:
19 | 
20 |   * **disableCache** - Disable caching & redis (defaults to false)
21 |   * **redis** - Redis configuration object (host, port, db)
22 |   * **cacheExpire** - Cache expiration in seconds for checked keys (set 0 for eternity, defaults to 24h)
23 | 
24 | ### Check connection settings
25 | 
26 | Check IMAP connection settings with autoconfig.detect
27 | 
28 |     detector.detect(address, password, cached, callback)
29 | 
30 | Where
31 | 
32 |   * **address** is the e-mail address to check
33 |   * **password** is the password for the user
34 |   * **cached** is a boolean indicator - if set to true, checks the data from a cache, otherwise checks the server
35 |   * **callback** is the callback function to run with an error object and imap settings object
36 | 
37 | Example
38 | 
39 |     detector.detect("pipemail@node.ee", "zzzzz", true, function(err, data){
40 |         console.log(err || data);
41 |     });
42 | 
43 | Response data object has the following properties
44 | 
45 |   * **host** is the IMAP hostname
46 |   * **port** is the port to the host
47 |   * **secure** indicates if the connection should be started with SSL (usually true for port 993 and false for 143)
48 |   * **user** indicates the format of the username, if it's *%EMAIL%* then, the IMAP username is also the email address, if it's *%USER%* then the local part of the user is the correct username, if it was unable to detect (password was not provided), it's set to false
49 |   * **expires** if the result came from cache, then this property indicates when the cache will be expired
50 | 
51 | Example value
52 | 
53 |     { 
54 |         host: 'imap.mail.yahoo.com',
55 |         port: '993',
56 |         secure: 'true',
57 |         user: '%EMAIL%',
58 |         expires: Thu Aug 09 2012 11:43:14 GMT+0300 (EEST) // Date object, not a String value
59 |     }
60 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
 1 | var defaultConfig = require("./config.json"),
 2 |     detect = require("./lib/detect"),
 3 |     redis = require("redis"),
 4 |     crypto = require("crypto");
 5 | 
 6 | module.exports.createIMAPSettingsDetector = createIMAPSettingsDetector;
 7 | 
 8 | function createIMAPSettingsDetector(config){
 9 |     config = config || defaultConfig;
10 |     config.redis = config.redis || defaultConfig.redis;
11 | 
12 |     if(typeof config.cacheExpire == "undefined"){
13 |         config.cacheExpire = defaultConfig.cacheExpire;
14 |     }
15 | 
16 |     if(typeof config.disableCache == "undefined"){
17 |         config.disableCache = defaultConfig.disableCache;
18 |     }
19 | 
20 |     return new IMAPSettingsDetector(config);
21 | }
22 | 
23 | function IMAPSettingsDetector(config){
24 |     this.config = config;
25 |     if (!this.config.disableCache) {
26 |       this.redisClient = redis.createClient(config.redis.port, config.redis.host);
27 |     }
28 | }
29 | 
30 | IMAPSettingsDetector.prototype.detect = function(address, password, cached, callback){
31 |     var args = Array.prototype.slice.call(arguments);
32 | 
33 |     callback = args.pop();
34 |     address = (args.shift() || "").toString();
35 |     password = (args.shift() || "").toString();
36 |     cached = !!args.shift();
37 | 
38 |     var cacheKey = "cache:autoconfig:"+sha1(address.split("@")[1] || "localhost");
39 | 
40 |     if(!this.config.disableCache && cached){
41 |         this.redisClient.multi().
42 |             select(this.config.redis.db).
43 |             hgetall(cacheKey).
44 |             ttl(cacheKey).
45 |             exec((function(err, replies){
46 |                 if(err){
47 |                     return callback(err);
48 |                 }
49 |                 if(replies && replies[1]){
50 |                     if(replies[2]){
51 |                         replies[1].expires = new Date(Date.now() + replies[2]*1000);
52 |                     }
53 |                     
54 |                     //console.log("Cache hit (expires " +replies[1].expires+ ")");
55 |                     return callback(null, replies[1]);
56 |                 }
57 |                 //console.log("Cache miss");
58 |                 this._checkSettings(address, password, cacheKey, callback);
59 |             }).bind(this));
60 |     }else{
61 |         this._checkSettings(address, password, cacheKey, callback);
62 |     }
63 | }
64 | 
65 | IMAPSettingsDetector.prototype._checkSettings = function(address, password, cacheKey, callback){
66 |     detect.detectIMAPSettings(address, password, (function(err, settings){
67 |         
68 |         if(err){
69 |             return callback(err);
70 |         }
71 | 
72 |         if(!settings){
73 |             return callback(null, null);
74 |         }
75 | 
76 |         // overwrite cache only with a valid user information
77 |         if(!this.config.disableCache && settings.user){
78 |             this.redisClient.multi().
79 |                 select(this.config.redis.db).
80 |                 hmset(cacheKey, settings).
81 |                 expire(cacheKey, this.config.cacheExpire || 0).
82 |                 exec((function(err){
83 |                     callback(null, settings);
84 |                 }).bind(this));    
85 |         }else{
86 |             callback(null, settings);
87 |         }
88 | 
89 |     }).bind(this));
90 | }
91 | 
92 | 
93 | function sha1(str){
94 |     var hash = crypto.createHash("sha1");
95 |     hash.update(str);
96 |     return hash.digest("hex");
97 | }
98 | 


--------------------------------------------------------------------------------
/lib/detect.js:
--------------------------------------------------------------------------------
  1 | var autoconfig = require("./autoconfig"),
  2 |     dnscheck = require("./dnscheck"),
  3 |     guess = require("./guess"),
  4 |     inbox = require("inbox");
  5 | 
  6 | module.exports.detectIMAPSettings = detectIMAPSettings;
  7 | 
  8 | function detectIMAPConnectionSettings(address, password, callback){
  9 |     if(!callback && typeof password == "function"){
 10 |         callback = password;
 11 |         password = undefined;
 12 |     }
 13 | 
 14 |     autoconfig.detectIMAPConnectionSettings.bind(autoconfig)(address, password, function(err, data){
 15 |         if(data){
 16 |             return callback(null, data);
 17 |         }else{
 18 |             dnscheck.detectIMAPConnectionSettings.bind(dnscheck)(address, password, function(err, data){
 19 |                 if(data){
 20 |                     return callback(null, data);
 21 |                 }else{
 22 |                     guess.detectIMAPConnectionSettings.bind(guess)(address, password, function(err, data){
 23 |                         if(data){
 24 |                             return callback(null, data);
 25 |                         }else{
 26 |                           return callback(null, null);
 27 |                         }
 28 |                     });
 29 |                 }
 30 |             });
 31 |         }
 32 |     });
 33 | }
 34 | 
 35 | function checkLoginData(port, host, options, callback){
 36 |     var client = inbox.createConnection(port, host, options),
 37 |         done = false;
 38 |     client.connect();
 39 |     client.on("connect", function(){
 40 |         if(done){return;}
 41 |         done = true;
 42 |         client.close();
 43 |         callback(null, true);
 44 |     });
 45 | 
 46 |     client.on("error", function(err){
 47 |         if(done){return;}
 48 |         done = true;
 49 |         client.close();
 50 |         callback(err);
 51 |     });
 52 | }
 53 | 
 54 | function detectIMAPUserSettings(address, password, settings, callback){
 55 | 
 56 |     var inboxSettings = {
 57 |             secureConnection: !!settings.secure,
 58 |             auth: {
 59 |                 pass: password
 60 |             }
 61 |         };
 62 | 
 63 |     inboxSettings.auth.user = address;
 64 | 
 65 |     checkLoginData(settings.port, settings.host, inboxSettings, function(err, success){
 66 |         if(err){
 67 |             inboxSettings.auth.user = address.split("@")[0];
 68 |             checkLoginData(settings.port, settings.host, inboxSettings, function(err, success){
 69 |                 if(err){
 70 |                     return callback(err);
 71 |                 }
 72 |                 callback(null, "%USER%");
 73 |             });
 74 |         }else{
 75 |             callback(null, "%EMAIL%");
 76 |         }
 77 |     });
 78 | 
 79 | }
 80 | 
 81 | 
 82 | function detectIMAPSettings(address, password, callback){
 83 |     if(!callback && typeof password == "function"){
 84 |         callback = password;
 85 |         password = undefined;
 86 |     }
 87 | 
 88 |     detectIMAPConnectionSettings(address, password, function(err, settings){
 89 |         if(err){
 90 |             return callback(err);
 91 |         }
 92 | 
 93 |         if(settings && password){
 94 |             detectIMAPUserSettings(address, password, settings, function(err, user){
 95 |                 if(err){
 96 |                     settings.user = false;
 97 |                     settings.error = err.message;
 98 |                 }else{
 99 |                     settings.user = user;
100 |                 }
101 | 
102 |                 callback(null, settings);
103 |             });
104 |         }else{
105 |             callback(null, settings);
106 |         }
107 |     });
108 | }


--------------------------------------------------------------------------------
/lib/guess.js:
--------------------------------------------------------------------------------
  1 | var dns = require('dns'),
  2 |     net = require("net"),
  3 |     tls = require("tls");
  4 | 
  5 | module.exports.detectIMAPConnectionSettings = detectIMAPConnectionSettings;
  6 | 
  7 | var domains = [
  8 |         "imap.%DOMAIN%",
  9 |         "mail.%DOMAIN%",
 10 |         "%DOMAIN%"
 11 |     ],
 12 | 
 13 |     ports = [
 14 |         993,
 15 |         143
 16 |     ],
 17 | 
 18 |     autoroute = {
 19 |         "aspmx.l.google.com":{
 20 |             port: 993,
 21 |             host: "imap.gmail.com",
 22 |             secure: true
 23 |         },
 24 |         "alt1.aspmx.l.google.com":{
 25 |             port: 993,
 26 |             host: "imap.gmail.com",
 27 |             secure: true
 28 |         },
 29 |         "alt2.aspmx.l.google.com":{
 30 |             port: 993,
 31 |             host: "imap.gmail.com",
 32 |             secure: true
 33 |         }
 34 |     };
 35 | 
 36 | 
 37 | 
 38 | function detectIMAPConnectionSettings(address, password, callback){
 39 |     if(!callback && typeof password == "function"){
 40 |         callback = password;
 41 |         password = undefined;
 42 |     }
 43 | 
 44 |     var checkdomains = [],
 45 |         parts = (address || "").toString().split("@"),
 46 |         user = parts.shift() || "",
 47 |         domain = parts.pop() || "",
 48 |         matrix;
 49 | 
 50 |     if(!user || !domain){
 51 |         return callback(new Error("Data missing"));
 52 |     }
 53 | 
 54 |     for(var i=0, len = domains.length; i<len; i++){
 55 |         checkdomains.push(domains[i].replace(/%USER%/g, user).replace(/%DOMAIN%/g, domain));
 56 |     }
 57 | 
 58 |     getMXDomain(domain, function(err, mxdomain){
 59 |         if(mxdomain){
 60 |             if(autoroute[mxdomain]){
 61 |                 return callback(null, autoroute[mxdomain]);
 62 |             }
 63 | 
 64 |             checkdomains.push(mxdomain.replace(/%USER%/g, user).replace(/%DOMAIN%/g, domain));       
 65 |         }
 66 | 
 67 |         matrix = generateCheckMatrix(checkdomains);
 68 | 
 69 |         checkMatrix(matrix, callback);
 70 |     });
 71 | }
 72 | 
 73 | function checkMatrix(matrix, callback){
 74 |     var waitingFor = matrix.length,
 75 |         ready = false;
 76 |     for(var i=0, len = matrix.length; i<len; i++){
 77 |         checkConnection(matrix[i], function(err, data){
 78 |             waitingFor--;
 79 | 
 80 |             if(ready){
 81 |                 return;
 82 |             }
 83 |             
 84 |             if(data){
 85 |                 ready = true;
 86 |                 return callback(null, data);
 87 |             }
 88 | 
 89 |             if(waitingFor == 0){
 90 |                 return callback(null, null);
 91 |             }
 92 |         });
 93 |     }
 94 | }
 95 | 
 96 | function checkConnection(connectionData, callback){
 97 |     var func, socket, ready = false;
 98 |     
 99 |     if(connectionData.secure){
100 |         func = tls.connect.bind(tls, {
101 |             port: connectionData.port || 993,
102 |             host: connectionData.host
103 |         });
104 |     }else{
105 |         func = net.connect.bind(net, connectionData.port || 143, connectionData.host);
106 |     }
107 | 
108 |     socket = func();
109 |     socket.setTimeout(1500);
110 | 
111 |     socket.on("timeout", function(){
112 |         if(!ready){
113 |             callback(new Error("Timeout"));
114 |         }
115 |         if(socket && !socket.destroyed){
116 |             socket.destroy();
117 |         }
118 |     });
119 | 
120 |     socket.on("error", function(err){
121 |         if(!ready){
122 |             callback(err);    
123 |         }
124 |         if(socket && !socket.destroyed){
125 |             socket.destroy();
126 |         }
127 |     });
128 | 
129 |     socket.on("data", function(chunk){
130 |         if(ready){
131 |             return;
132 |         }
133 |         ready = true;
134 |         if((chunk || "").toString("utf-8").substr(0,4) == "* OK"){
135 |             callback(null, connectionData);
136 |             if(socket && !socket.destroyed){
137 |                 socket.destroy();
138 |             }
139 |         }else{
140 |             callback(null, null);
141 |             if(socket && !socket.destroyed){
142 |                 socket.destroy();
143 |             }
144 |         }
145 |     });
146 | }
147 | 
148 | function generateCheckMatrix(checkdomains){
149 |     var matrix = [];
150 |     
151 |     ports.forEach(function(port){
152 |         checkdomains.forEach(function(domain){
153 |             matrix.push({
154 |                 host: domain,
155 |                 port: port,
156 |                 secure: port == 993
157 |             });
158 |         });
159 |     });
160 | 
161 |     return matrix;
162 | }
163 | 
164 | function getMXDomain(domain, callback){
165 |      dns.resolve(domain, "MX", function(err, addresses){
166 |         if(err){
167 |             return callback(err);
168 |         }
169 |         if(!addresses || !addresses.length){
170 |             return callback(null, null);
171 |         }
172 | 
173 |         addresses.sort(function(a,b){
174 |             return a.priority - b.priority;
175 |         });
176 | 
177 |         callback(null, (addresses[0].exchange || "").toString().toLowerCase().trim());
178 |     });
179 | }
180 | 


--------------------------------------------------------------------------------
/lib/autoconfig.js:
--------------------------------------------------------------------------------
  1 | var xml2object = require("xml2object"),
  2 |     fetch = require("fetch"),
  3 |     dns = require('dns');
  4 | 
  5 | module.exports.listServiceURLs = listServiceURLs;
  6 | module.exports.checkConfigUrl = checkConfigUrl;
  7 | module.exports.detectIMAPConnectionSettings = detectIMAPConnectionSettings;
  8 | 
  9 | // https://developer.mozilla.org/en/Thunderbird/Autoconfiguration
 10 | // http://technet.microsoft.com/en-us/library/cc511507.aspx
 11 | 
 12 | var serviceURLs = [
 13 |     "http://autoconfig.%DOMAIN%/mail/config-v1.1.xml?emailaddress=%USER%@%DOMAIN%",
 14 |     "http://%DOMAIN%/.well-known/autoconfig/mail/config-v1.1.xml",
 15 |     "https://autoconfig-live.mozillamessaging.com/autoconfig/v1.1/%DOMAIN%",
 16 |     "https://live.mozillamessaging.com/autoconfig/%DOMAIN%",
 17 |     "https://%DOMAIN%/autodiscover/autodiscover.xml",
 18 |     "http://%DOMAIN%/autodiscover/autodiscover.xml",
 19 |     "https://autodiscover.%DOMAIN%/autodiscover/autodiscover.xml",
 20 |     "http://autodiscover.%DOMAIN%/autodiscover/autodiscover.xml"
 21 | ];
 22 | 
 23 | function detectIMAPConnectionSettings(address, password, callback){
 24 |     if(!callback && typeof password == "function"){
 25 |         callback = password;
 26 |         password = undefined;
 27 |     }
 28 | 
 29 |     listServiceURLs(address, function(err, urls){
 30 |         if(err){
 31 |             return callback(err);
 32 |         }
 33 |         checkServiceURLs(urls, address, password, callback);
 34 |     });
 35 | }
 36 | 
 37 | function checkServiceURLs(urls, address, password, callback){
 38 |     var waitingFor = urls.length,
 39 |         ready = false;
 40 | 
 41 |     for(var i=0, len = urls.length; i<len; i++){
 42 |         checkConfigUrl(urls[i], {
 43 |                 username: address,
 44 |                 password: password
 45 |             }, function(err, data){
 46 |                 waitingFor--;
 47 | 
 48 |                 if(ready){
 49 |                     return;
 50 |                 }
 51 |                 
 52 |                 if(data){
 53 |                     ready = true;
 54 |                     return callback(null, data);
 55 |                 }
 56 | 
 57 |                 if(waitingFor == 0){
 58 |                     return callback(null, null);
 59 |                 }
 60 |             });
 61 |     }
 62 | }
 63 | 
 64 | function digServiceUrl(domain, callback){
 65 |     dns.resolve("_autodiscover._tcp."+domain, "SRV", function(err, addresses){
 66 |         var url;
 67 |         if(err){
 68 |             return callback(err);
 69 |         }
 70 |         if(!addresses || !addresses.length){
 71 |             return callback(null, null);
 72 |         }
 73 | 
 74 |         url = (addresses[0].port == 443? "https://":"http://") + 
 75 |                 addresses[0].name + 
 76 |                 ([80, 443].indexOf(addresses[0].port)<0?":"+addresses[0].port:"");
 77 |         url += "/autodiscover/autodiscover.xml";
 78 | 
 79 |         callback(null, url);
 80 |     })
 81 | }
 82 | 
 83 | function listServiceURLs(address, callback){
 84 |     var parts = (address || "").toString().split("@"),
 85 |         user = parts.shift() || "",
 86 |         domain = parts.pop() || "",
 87 |         response = [];
 88 | 
 89 |     if(!user || !domain){
 90 |         return callback(new Error("Data missing"));
 91 |     }
 92 | 
 93 |     for(var i=0, len = serviceURLs.length; i<len; i++){
 94 |         response.push(serviceURLs[i].replace(/%USER%/g, user).replace(/%DOMAIN%/g, domain));
 95 |     }
 96 | 
 97 |     digServiceUrl(domain, function(err, url){
 98 |         if(url){
 99 |             response.push(url.replace(/%USER%/g, user).replace(/%DOMAIN%/g, domain));
100 |         }
101 |         return callback(null, response);
102 |     });
103 | 
104 | }
105 | 
106 | 
107 | function fetchConfigStream(url, options, callback){
108 |     if(!callback && typeof options == "function"){
109 |         callback = options;
110 |         options = undefined;
111 |     }
112 | 
113 |     options = options || {};
114 |     options.headers = options.headers || {};
115 |     options.timeout = 3000;
116 | 
117 |     var stream = new fetch.FetchStream(url, options);
118 |     stream.on("error", callback);
119 | 
120 |     stream.on("meta", function(meta){
121 |         if(meta.status == 401){
122 |             if((meta.responseHeaders['www-authenticate'] || "").match(/\bbasic\b/i)){
123 |                 if(!options.username && !options.password){
124 |                     return callback(new Error("401 Authorization Required"));
125 |                 }
126 |                 if(!options.headers.authorization){
127 |                     options.headers.authorization = "Basic "+ (new Buffer(options.username+":"+options.password,"utf-8").toString("base64"));
128 |                 }else if(options.username.match(/@/)){
129 |                     options.username = options.username.match(/^[^@]+/)[0];
130 |                     options.headers.authorization = "Basic "+ (new Buffer(options.username+":"+options.password,"utf-8").toString("base64"));
131 |                 }else{
132 |                     return callback(new Error("401 Authorization Required"));
133 |                 }
134 |                 return fetchConfigStream(url, options, callback);
135 |             }
136 |         }
137 |         if(meta.status != 200){
138 |             return callback(new Error("Invalid response " + meta.status));
139 |         }
140 |         return callback(null, stream);
141 |     });
142 | }
143 | 
144 | function parseConfigXML(sourceStream, callback){
145 |     var ready = false;
146 | 
147 |     sourceStream.on("error", function(err){
148 |         if(ready){
149 |             return;
150 |         }
151 |         ready = true;
152 |         return callback(err);
153 |     });
154 | 
155 |     var parser = new xml2object(["Protocol", "incomingServer"]);
156 | 
157 |     parser.on("object", function(name, obj) {
158 |         var data = {};
159 |         if(ready){
160 |             return;
161 |         }
162 |         if((obj.Type || obj.type || "").toLowerCase() == "imap"){
163 |             ready = true;
164 |             data.host = (obj.hostname || obj.Server || "");
165 |             data.port = (obj.port || obj.Port || "");
166 |             data.secure = !!(obj.socketType == "SSL" || obj.SSL == "on");
167 |             return callback(null, data);
168 |         }
169 |     });
170 | 
171 |     parser.on("end", function() {
172 |         if(ready){
173 |             return;
174 |         }
175 |         ready = true;
176 |         return callback(null, null);
177 |     });
178 | 
179 |     parser.on("error", function(err) {
180 |         if(ready){
181 |             return;
182 |         }
183 |         ready = true;
184 |         return callback(err);
185 |     });
186 | 
187 |     sourceStream.pipe(parser.saxStream);
188 | }
189 | 
190 | function checkConfigUrl(url, options, callback){
191 | 
192 |     if(!callback && typeof options == "function"){
193 |         callback = options;
194 |         options = undefined;
195 |     }
196 | 
197 |     fetchConfigStream(url, options, function(err, stream){
198 |         if(err){
199 |             return callback(err);
200 |         }
201 |         if(!stream){
202 |             return callback(null, null);
203 |         }
204 |         parseConfigXML(stream, callback);
205 |     });
206 | }
207 | 


--------------------------------------------------------------------------------