source: filezilla/trunk/fuentes/src/engine/server.cpp @ 130

Last change on this file since 130 was 130, checked in by jrpelegrina, 4 years ago

First release to xenial

File size: 18.7 KB
Line 
1#include <filezilla.h>
2
3struct t_protocolInfo
4{
5        const ServerProtocol protocol;
6        const wxString prefix;
7        bool alwaysShowPrefix;
8        unsigned int defaultPort;
9        const bool translateable;
10        const wxChar* const name;
11        bool supportsPostlogin;
12};
13
14static const t_protocolInfo protocolInfos[] = {
15        { FTP,          _T("ftp"),    false, 21,  true,  TRANSLATE_T("FTP - File Transfer Protocol with optional encryption"),                 true  },
16        { SFTP,         _T("sftp"),   true,  22,  false, _T("SFTP - SSH File Transfer Protocol"),                              false },
17        { HTTP,         _T("http"),   true,  80,  false, _T("HTTP - Hypertext Transfer Protocol"),                             false  },
18        { HTTPS,        _T("https"),  true, 443,  true,  TRANSLATE_T("HTTPS - HTTP over TLS"),                                 false  },
19        { FTPS,         _T("ftps"),   true, 990,  true,  TRANSLATE_T("FTPS - FTP over implicit TLS"),                      true  },
20        { FTPES,        _T("ftpes"),  true,  21,  true,  TRANSLATE_T("FTPES - FTP over explicit TLS"),                     true  },
21        { INSECURE_FTP, _T("ftp"),    false, 21,  true,  TRANSLATE_T("FTP - Insecure File Transfer Protocol"), true  },
22        { UNKNOWN,      _T(""),       false, 21,  false, _T(""), false }
23};
24
25static const wxString typeNames[SERVERTYPE_MAX] = {
26        TRANSLATE_T("Default (Autodetect)"),
27        _T("Unix"),
28        _T("VMS"),
29        _T("DOS"),
30        _T("MVS, OS/390, z/OS"),
31        _T("VxWorks"),
32        _T("z/VM"),
33        _T("HP NonStop"),
34        TRANSLATE_T("DOS-like with virtual paths"),
35        _T("Cygwin")
36};
37
38static const t_protocolInfo& GetProtocolInfo(ServerProtocol protocol)
39{
40        unsigned int i = 0;
41        for ( ; protocolInfos[i].protocol != UNKNOWN; ++i)
42        {
43                if (protocolInfos[i].protocol == protocol)
44                        break;
45        }
46        return protocolInfos[i];
47}
48
49CServer::CServer()
50{
51        Initialize();
52}
53
54bool CServer::ParseUrl(wxString host, wxString port, wxString user, wxString pass, wxString &error, CServerPath &path)
55{
56        unsigned long nPort = 0;
57        if (!port.empty())
58        {
59                port.Trim(false);
60                port.Trim(true);
61                if (port.size() > 5 || !port.ToULong(&nPort) || !nPort || nPort > 65535)
62                {
63                        error = _("Invalid port given. The port has to be a value from 1 to 65535.");
64                        error += _T("\n");
65                        error += _("You can leave the port field empty to use the default port.");
66                        return false;
67                }
68        }
69        return ParseUrl(host, nPort, user, pass, error, path);
70}
71
72bool CServer::ParseUrl(wxString host, unsigned int port, wxString user, wxString pass, wxString &error, CServerPath &path)
73{
74        m_type = DEFAULT;
75
76        if (host.empty()) {
77                error = _("No host given, please enter a host.");
78                return false;
79        }
80
81        int pos = host.Find(_T("://"));
82        if (pos != -1) {
83                wxString protocol = host.Left(pos).Lower();
84                host = host.Mid(pos + 3);
85                if (protocol.Left(3) == _T("fz_"))
86                        protocol = protocol.Mid(3);
87                m_protocol = GetProtocolFromPrefix(protocol.Lower());
88                if (m_protocol == UNKNOWN)
89                {
90                        // TODO: http:// once WebDAV is officially supported
91                        error = _("Invalid protocol specified. Valid protocols are:\nftp:// for normal FTP with optional encryption,\nsftp:// for SSH file transfer protocol,\nftps:// for FTP over TLS (implicit) and\nftpes:// for FTP over TLS (explicit).");
92                        return false;
93                }
94        }
95
96        pos = host.Find('@');
97        if (pos != -1) {
98                // Check if it's something like
99                //   user@name:password@host:port/path
100                // => If there are multiple at signs, username/port ends at last at before
101                // the first slash. (Since host and port never contain any at sign)
102
103                int slash = host.Mid(pos + 1).Find('/');
104                if (slash != -1)
105                        slash += pos + 1;
106
107                int next_at = host.Mid(pos + 1).Find('@');
108                while (next_at != -1) {
109                        next_at += pos + 1;
110                        if (slash != -1 && next_at > slash)
111                                break;
112
113                        pos = next_at;
114                        next_at = host.Mid(pos + 1).Find('@');
115                }
116
117                user = host.Left(pos);
118                host = host.Mid(pos + 1);
119
120                // Extract password (if any) from username
121                pos = user.Find(':');
122                if (pos != -1) {
123                        pass = user.Mid(pos + 1);
124                        user = user.Left(pos);
125                }
126
127                // Remove leading and trailing whitespace
128                user.Trim(true);
129                user.Trim(false);
130
131                if (user.empty()) {
132                        error = _("Invalid username given.");
133                        return false;
134                }
135        }
136        else {
137                // Remove leading and trailing whitespace
138                user.Trim(true);
139                user.Trim(false);
140
141                if (user.empty() && m_logonType != ASK && m_logonType != INTERACTIVE) {
142                        user = _T("anonymous");
143                        pass = _T("anonymous@example.com");
144                }
145        }
146
147        pos = host.Find('/');
148        if (pos != -1) {
149                path = CServerPath(host.Mid(pos));
150                host = host.Left(pos);
151        }
152
153        if (!host.empty() && host[0] == '[') {
154                // Probably IPv6 address
155                pos = host.Find(']');
156                if (pos == -1) {
157                        error = _("Host starts with '[' but no closing bracket found.");
158                        return false;
159                }
160                if (pos + 1 < static_cast<int>(host.Len()) ) {
161                        if (host[pos + 1] != ':') {
162                                error = _("Invalid host, after closing bracket only colon and port may follow.");
163                                return false;
164                        }
165                        ++pos;
166                }
167                else
168                        pos = -1;
169        }
170        else
171                pos = host.Find(':');
172        if (pos != -1) {
173                if (!pos) {
174                        error = _("No host given, please enter a host.");
175                        return false;
176                }
177
178                long tmp;
179                if (!host.Mid(pos + 1).ToLong(&tmp) || tmp < 1 || tmp > 65535) {
180                        error = _("Invalid port given. The port has to be a value from 1 to 65535.");
181                        return false;
182                }
183                port = tmp;
184                host = host.Left(pos);
185        }
186        else {
187                if (!port)
188                        port = GetDefaultPort(m_protocol);
189                else if (port > 65535) {
190                        error = _("Invalid port given. The port has to be a value from 1 to 65535.");
191                        return false;
192                }
193        }
194
195        host.Trim(true);
196        host.Trim(false);
197
198        if (host.empty()) {
199                error = _("No host given, please enter a host.");
200                return false;
201        }
202
203        m_host = host;
204
205        if (m_host[0] == '[') {
206                m_host.RemoveLast();
207                m_host = m_host.Mid(1);
208        }
209
210        m_port = port;
211        m_user = user;
212        m_pass = pass;
213        m_account.clear();
214        if (m_logonType != ASK && m_logonType != INTERACTIVE) {
215                if (m_user.empty())
216                        m_logonType = ANONYMOUS;
217                else if (m_user == _T("anonymous"))
218                        if (m_pass.empty() || m_pass == _T("anonymous@example.com"))
219                                m_logonType = ANONYMOUS;
220                        else
221                                m_logonType = NORMAL;
222                else
223                        m_logonType = NORMAL;
224        }
225
226        if (m_protocol == UNKNOWN)
227                m_protocol = GetProtocolFromPort(port);
228
229        return true;
230}
231
232ServerProtocol CServer::GetProtocol() const
233{
234        return m_protocol;
235}
236
237ServerType CServer::GetType() const
238{
239        return m_type;
240}
241
242wxString CServer::GetHost() const
243{
244        return m_host;
245}
246
247unsigned int CServer::GetPort() const
248{
249        return m_port;
250}
251
252wxString CServer::GetUser() const
253{
254        if (m_logonType == ANONYMOUS)
255                return _T("anonymous");
256
257        return m_user;
258}
259
260wxString CServer::GetPass() const
261{
262        if (m_logonType == ANONYMOUS)
263                return _T("anon@localhost");
264
265        return m_pass;
266}
267
268wxString CServer::GetAccount() const
269{
270        if (m_logonType != ACCOUNT)
271                return wxString();
272
273        return m_account;
274}
275
276wxString CServer::GetKeyFile() const
277{
278        if (m_logonType != KEY)
279                return wxString();
280
281        return m_keyFile;
282}
283
284CServer& CServer::operator=(const CServer &op)
285{
286        m_protocol = op.m_protocol;
287        m_type = op.m_type;
288        m_host = op.m_host;
289        m_port = op.m_port;
290        m_logonType = op.m_logonType;
291        m_user = op.m_user;
292        m_pass = op.m_pass;
293        m_account = op.m_account;
294        m_keyFile = op.m_keyFile;
295        m_timezoneOffset = op.m_timezoneOffset;
296        m_pasvMode = op.m_pasvMode;
297        m_maximumMultipleConnections = op.m_maximumMultipleConnections;
298        m_encodingType = op.m_encodingType;
299        m_customEncoding = op.m_customEncoding;
300        m_postLoginCommands = op.m_postLoginCommands;
301        m_bypassProxy = op.m_bypassProxy;
302        m_name = op.m_name;
303
304        return *this;
305}
306
307bool CServer::operator==(const CServer &op) const
308{
309        if (m_protocol != op.m_protocol)
310                return false;
311        else if (m_type != op.m_type)
312                return false;
313        else if (m_host != op.m_host)
314                return false;
315        else if (m_port != op.m_port)
316                return false;
317        else if (m_logonType != op.m_logonType)
318                return false;
319        else if (m_logonType != ANONYMOUS)
320        {
321                if (m_user != op.m_user)
322                        return false;
323
324                if (m_logonType == NORMAL)
325                {
326                        if (m_pass != op.m_pass)
327                                return false;
328                }
329                else if (m_logonType == ACCOUNT)
330                {
331                        if (m_pass != op.m_pass)
332                                return false;
333                        if (m_account != op.m_account)
334                                return false;
335                }
336                else if (m_logonType == KEY)
337                {
338                        if (m_keyFile != op.m_keyFile)
339                                return false;
340                }
341        }
342        if (m_timezoneOffset != op.m_timezoneOffset)
343                return false;
344        else if (m_pasvMode != op.m_pasvMode)
345                return false;
346        else if (m_encodingType != op.m_encodingType)
347                return false;
348        else if (m_encodingType == ENCODING_CUSTOM)
349        {
350                if (m_customEncoding != op.m_customEncoding)
351                        return false;
352        }
353        if (m_postLoginCommands != op.m_postLoginCommands)
354                return false;
355        if (m_bypassProxy != op.m_bypassProxy)
356                return false;
357
358        // Do not compare number of allowed multiple connections
359
360        return true;
361}
362
363bool CServer::operator<(const CServer &op) const
364{
365        if (m_protocol < op.m_protocol)
366                return true;
367        else if (m_protocol > op.m_protocol)
368                return false;
369
370        if (m_type < op.m_type)
371                return true;
372        else if (m_type > op.m_type)
373                return false;
374
375        int cmp = m_host.Cmp(op.m_host);
376        if (cmp < 0)
377                return true;
378        else if (cmp > 0)
379                return false;
380
381        if (m_port < op.m_port)
382                return true;
383        else if (m_port > op.m_port)
384                return false;
385
386        if (m_logonType < op.m_logonType)
387                return true;
388        else if (m_logonType > op.m_logonType)
389                return false;
390
391        if (m_logonType != ANONYMOUS)
392        {
393                cmp = m_user.Cmp(op.m_user);
394                if (cmp < 0)
395                        return true;
396                else if (cmp > 0)
397                        return false;
398
399                if (m_logonType == NORMAL)
400                {
401                        cmp = m_pass.Cmp(op.m_pass);
402                        if (cmp < 0)
403                                return true;
404                        else if (cmp > 0)
405                                return false;
406                }
407                else if (m_logonType == ACCOUNT)
408                {
409                        cmp = m_pass.Cmp(op.m_pass);
410                        if (cmp < 0)
411                                return true;
412                        else if (cmp > 0)
413                                return false;
414
415                        cmp = m_account.Cmp(op.m_account);
416                        if (cmp < 0)
417                                return true;
418                        else if (cmp > 0)
419                                return false;
420                }
421        }
422        if (m_timezoneOffset < op.m_timezoneOffset)
423                return true;
424        else if (m_timezoneOffset > op.m_timezoneOffset)
425                return false;
426
427        if (m_pasvMode < op.m_pasvMode)
428                return true;
429        else if (m_pasvMode > op.m_pasvMode)
430                return false;
431
432        if (m_encodingType < op.m_encodingType)
433                return true;
434        else if (m_encodingType > op.m_encodingType)
435                return false;
436
437        if (m_encodingType == ENCODING_CUSTOM)
438        {
439                if (m_customEncoding < op.m_customEncoding)
440                        return true;
441                else if (m_customEncoding > op.m_customEncoding)
442                        return false;
443        }
444        if (m_bypassProxy < op.m_bypassProxy)
445                return true;
446        else if (m_bypassProxy > op.m_bypassProxy)
447                return false;
448
449        // Do not compare number of allowed multiple connections
450
451        return false;
452}
453
454bool CServer::operator!=(const CServer &op) const
455{
456        return !(*this == op);
457}
458
459bool CServer::EqualsNoPass(const CServer &op) const
460{
461        if (m_protocol != op.m_protocol)
462                return false;
463        else if (m_type != op.m_type)
464                return false;
465        else if (m_host != op.m_host)
466                return false;
467        else if (m_port != op.m_port)
468                return false;
469        else if ((m_logonType == ANONYMOUS) != (op.m_logonType == ANONYMOUS))
470                return false;
471        else if ((m_logonType == ACCOUNT) != (op.m_logonType == ACCOUNT))
472                return false;
473        else if (m_logonType != ANONYMOUS)
474        {
475                if (m_user != op.m_user)
476                        return false;
477                if (m_logonType == ACCOUNT)
478                        if (m_account != op.m_account)
479                                return false;
480        }
481        if (m_timezoneOffset != op.m_timezoneOffset)
482                return false;
483        else if (m_pasvMode != op.m_pasvMode)
484                return false;
485        else if (m_encodingType != op.m_encodingType)
486                return false;
487        else if (m_encodingType == ENCODING_CUSTOM) {
488                if (m_customEncoding != op.m_customEncoding)
489                        return false;
490        }
491        if (m_postLoginCommands != op.m_postLoginCommands)
492                return false;
493        if (m_bypassProxy != op.m_bypassProxy)
494                return false;
495
496        // Do not compare number of allowed multiple connections
497
498        return true;
499}
500
501CServer::CServer(ServerProtocol protocol, ServerType type, wxString host, unsigned int port, wxString user, wxString pass, wxString account)
502{
503        Initialize();
504        m_protocol = protocol;
505        m_type = type;
506        m_host = host;
507        m_port = port;
508        m_logonType = NORMAL;
509        m_user = user;
510        m_pass = pass;
511        m_account = account;
512}
513
514CServer::CServer(ServerProtocol protocol, ServerType type, wxString host, unsigned int port)
515{
516        Initialize();
517        m_protocol = protocol;
518        m_type = type;
519        m_host = host;
520        m_port = port;
521}
522
523void CServer::SetType(ServerType type)
524{
525        m_type = type;
526}
527
528LogonType CServer::GetLogonType() const
529{
530        return m_logonType;
531}
532
533void CServer::SetLogonType(LogonType logonType)
534{
535        wxASSERT(logonType != LOGONTYPE_MAX);
536        m_logonType = logonType;
537}
538
539void CServer::SetProtocol(ServerProtocol serverProtocol)
540{
541        wxASSERT(serverProtocol != UNKNOWN);
542
543        if (!GetProtocolInfo(serverProtocol).supportsPostlogin)
544                m_postLoginCommands.clear();
545
546        m_protocol = serverProtocol;
547}
548
549bool CServer::SetHost(wxString host, unsigned int port)
550{
551        if (host.empty())
552                return false;
553
554        if (port < 1 || port > 65535)
555                return false;
556
557        m_host = host;
558        m_port = port;
559
560        if (m_protocol == UNKNOWN)
561                m_protocol = GetProtocolFromPort(m_port);
562
563        return true;
564}
565
566bool CServer::SetUser(const wxString& user, const wxString& pass)
567{
568        if (m_logonType == ANONYMOUS)
569                return true;
570
571        if (user.empty()) {
572                if (m_logonType != ASK && m_logonType != INTERACTIVE)
573                        return false;
574                m_pass.clear();
575        }
576        else
577                m_pass = pass;
578
579        m_user = user;
580
581        return true;
582}
583
584bool CServer::SetAccount(const wxString& account)
585{
586        if (m_logonType != ACCOUNT)
587                return false;
588
589        m_account = account;
590
591        return true;
592}
593
594bool CServer::SetKeyFile(const wxString& keyFile)
595{
596        if (m_logonType != KEY)
597                return false;
598
599        m_keyFile = keyFile;
600
601        return true;
602}
603
604bool CServer::SetTimezoneOffset(int minutes)
605{
606        if (minutes > (60 * 24) || minutes < (-60 * 24))
607                return false;
608
609        m_timezoneOffset = minutes;
610
611        return true;
612}
613
614int CServer::GetTimezoneOffset() const
615{
616        return m_timezoneOffset;
617}
618
619PasvMode CServer::GetPasvMode() const
620{
621        return m_pasvMode;
622}
623
624void CServer::SetPasvMode(PasvMode pasvMode)
625{
626        m_pasvMode = pasvMode;
627}
628
629void CServer::MaximumMultipleConnections(int maximumMultipleConnections)
630{
631        m_maximumMultipleConnections = maximumMultipleConnections;
632}
633
634int CServer::MaximumMultipleConnections() const
635{
636        return m_maximumMultipleConnections;
637}
638
639wxString CServer::FormatHost(bool always_omit_port /*=false*/) const
640{
641        wxString host = m_host;
642
643        if (host.Find(':') != -1)
644                host = _T("[") + host + _T("]");
645
646        if (!always_omit_port)
647        {
648                if (m_port != GetDefaultPort(m_protocol))
649                        host += wxString::Format(_T(":%d"), m_port);
650        }
651
652        return host;
653}
654
655wxString CServer::FormatServer(const bool always_include_prefix /*=false*/) const
656{
657        wxString server = FormatHost();
658
659        if (m_logonType != ANONYMOUS)
660                server = GetUser() + _T("@") + server;
661
662        const t_protocolInfo& info = GetProtocolInfo(m_protocol);
663        if (!info.prefix.empty())
664        {
665                if (always_include_prefix || info.alwaysShowPrefix)
666                        server = info.prefix + _T("://") + server;
667                else if (m_port != info.defaultPort)
668                        server = info.prefix + _T("://") + server;
669        }
670
671        return server;
672}
673
674void CServer::Initialize()
675{
676        m_protocol = UNKNOWN;
677        m_type = DEFAULT;
678        m_host.clear();
679        m_port = 21;
680        m_logonType = ANONYMOUS;
681        m_user.clear();
682        m_pass.clear();
683        m_account.clear();
684        m_timezoneOffset = 0;
685        m_pasvMode = MODE_DEFAULT;
686        m_maximumMultipleConnections = 0;
687        m_encodingType = ENCODING_AUTO;
688        m_customEncoding.clear();
689        m_bypassProxy = false;
690}
691
692bool CServer::SetEncodingType(CharsetEncoding type, const wxString& encoding)
693{
694        if (type == ENCODING_CUSTOM && encoding.empty())
695                return false;
696
697        m_encodingType = type;
698        m_customEncoding = encoding;
699
700        return true;
701}
702
703bool CServer::SetCustomEncoding(const wxString& encoding)
704{
705        if (encoding.empty())
706                return false;
707
708        m_encodingType = ENCODING_CUSTOM;
709        m_customEncoding = encoding;
710
711        return true;
712}
713
714CharsetEncoding CServer::GetEncodingType() const
715{
716        return m_encodingType;
717}
718
719wxString CServer::GetCustomEncoding() const
720{
721        return m_customEncoding;
722}
723
724unsigned int CServer::GetDefaultPort(ServerProtocol protocol)
725{
726        const t_protocolInfo& info = GetProtocolInfo(protocol);
727
728        return info.defaultPort;
729}
730
731ServerProtocol CServer::GetProtocolFromPort(unsigned int port, bool defaultOnly /*=false*/)
732{
733        for (unsigned int i = 0; protocolInfos[i].protocol != UNKNOWN; ++i)
734        {
735                if (protocolInfos[i].defaultPort == port)
736                        return protocolInfos[i].protocol;
737        }
738
739        if (defaultOnly)
740                return UNKNOWN;
741
742        // Else default to FTP
743        return FTP;
744}
745
746wxString CServer::GetProtocolName(ServerProtocol protocol)
747{
748        const t_protocolInfo *protocolInfo = protocolInfos;
749        while (protocolInfo->protocol != UNKNOWN)
750        {
751                if (protocolInfo->protocol != protocol)
752                {
753                        ++protocolInfo;
754                        continue;
755                }
756
757                if (protocolInfo->translateable)
758                        return wxGetTranslation(protocolInfo->name);
759                else
760                        return protocolInfo->name;
761        }
762
763        return wxString();
764}
765
766ServerProtocol CServer::GetProtocolFromName(const wxString& name)
767{
768        const t_protocolInfo *protocolInfo = protocolInfos;
769        while (protocolInfo->protocol != UNKNOWN) {
770                if (protocolInfo->translateable) {
771                        if (wxGetTranslation(protocolInfo->name) == name)
772                                return protocolInfo->protocol;
773                }
774                else {
775                        if (protocolInfo->name == name)
776                                return protocolInfo->protocol;
777                }
778                ++protocolInfo;
779        }
780
781        return UNKNOWN;
782}
783
784bool CServer::SetPostLoginCommands(const std::vector<wxString>& postLoginCommands)
785{
786        if (!SupportsPostLoginCommands(m_protocol)) {
787                m_postLoginCommands.clear();
788                return false;
789        }
790
791        m_postLoginCommands = postLoginCommands;
792        return true;
793}
794
795bool CServer::SupportsPostLoginCommands(ServerProtocol const protocol)
796{
797        return protocol == FTP || protocol == FTPS || protocol == FTPES || protocol == INSECURE_FTP;
798}
799
800ServerProtocol CServer::GetProtocolFromPrefix(const wxString& prefix)
801{
802        for (unsigned int i = 0; protocolInfos[i].protocol != UNKNOWN; ++i) {
803                if (!protocolInfos[i].prefix.CmpNoCase(prefix))
804                        return protocolInfos[i].protocol;
805        }
806
807        return UNKNOWN;
808}
809
810wxString CServer::GetPrefixFromProtocol(const ServerProtocol protocol)
811{
812        const t_protocolInfo& info = GetProtocolInfo(protocol);
813
814        return info.prefix;
815}
816
817void CServer::SetBypassProxy(bool val)
818{
819  m_bypassProxy = val;
820}
821
822bool CServer::GetBypassProxy() const
823{
824  return m_bypassProxy;
825}
826
827bool CServer::ProtocolHasDataTypeConcept(const ServerProtocol protocol)
828{
829        if (protocol == FTP || protocol == FTPS || protocol == FTPES || protocol == INSECURE_FTP)
830                return true;
831
832        return false;
833}
834
835wxString CServer::GetNameFromServerType(ServerType type)
836{
837        wxASSERT(type != SERVERTYPE_MAX);
838        return wxGetTranslation(typeNames[type]);
839}
840
841ServerType CServer::GetServerTypeFromName(const wxString& name)
842{
843        for (int i = 0; i < SERVERTYPE_MAX; ++i) {
844                ServerType type = static_cast<ServerType>(i);
845                if (name == CServer::GetNameFromServerType(type))
846                        return type;
847        }
848
849        return DEFAULT;
850}
851
852LogonType CServer::GetLogonTypeFromName(const wxString& name)
853{
854        if (name == _("Normal"))
855                return NORMAL;
856        else if (name == _("Ask for password"))
857                return ASK;
858        else if (name == _("Key file"))
859                return KEY;
860        else if (name == _("Interactive"))
861                return INTERACTIVE;
862        else if (name == _("Account"))
863                return ACCOUNT;
864        else
865                return ANONYMOUS;
866}
867
868wxString CServer::GetNameFromLogonType(LogonType type)
869{
870        wxASSERT(type != LOGONTYPE_MAX);
871
872        switch (type)
873        {
874        case NORMAL:
875                return _("Normal");
876        case ASK:
877                return _("Ask for password");
878        case KEY:
879                return _("Key file");
880        case INTERACTIVE:
881                return _("Interactive");
882        case ACCOUNT:
883                return _("Account");
884        default:
885                return _("Anonymous");
886        }
887}
Note: See TracBrowser for help on using the repository browser.