← Back to branch summary

~ubuntu-branches/ubuntu/utopic/dovecot/utopic-proposed

« back to all changes in this revision

Viewing changes to .pc/split-protocols.patch/src/config/all-settings.c

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-01-08 09:35:49 UTC
  • mfrom: (4.1.35 sid)
  • Revision ID: package-import@ubuntu.com-20140108093549-i72o93pux8p0dlaf
Tags: 1:2.2.9-1ubuntu1
* Merge from Debian unstable, remaining changes:
  + Add mail-stack-delivery package:
    - Update d/rules
    - d/control: convert existing dovecot-postfix package to a dummy
      package and add new mail-stack-delivery package.
    - Update maintainer scripts.
    - Rename d/dovecot-postfix.* to debian/mail-stack-delivery.*
    - d/mail-stack-delivery.preinst: Move previously installed backups and
      config files to a new package namespace.
    - d/mail-stack-delivery.prerm: Added to handle downgrades.
  + Use Snakeoil SSL certificates by default:
    - d/control: Depend on ssl-cert.
    - d/dovecot-core.postinst: Relax grep for SSL_* a bit.
  + Add autopkgtest to debian/tests/*.
  + Add ufw integration:
    - d/dovecot-core.ufw.profile: new ufw profile.
    - d/rules: install profile in dovecot-core.
    - d/control: dovecot-core - suggest ufw.
  + d/dovecot-core.dirs: Added usr/share/doc/dovecot-core
  + Add apport hook:
    - d/rules, d/source_dovecot.py
  + Add upstart job:
    - d/rules, d/dovecot-core.dovecot.upstart, d/control,
      d/dovecot-core.dirs, dovecot-imapd.{postrm, postinst, prerm},
      d/dovecot-pop3d.{postinst, postrm, prerm}.
      d/mail-stack-deliver.postinst: Convert init script to upstart.
  + Use the autotools-dev dh addon to update config.guess/config.sub for
    arm64.
* Dropped changes, included in Debian:
  - Update Dovecot name to reflect distribution in login greeting.
  - Update Drac plugin for >= 2.0.0 support.
* d/control: Drop dovecot-postfix package as its no longer required.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/split-protocols.patch/src/config/all-settings.c
5
5
#include "file-lock.h"
6
6
#include "fsync-mode.h"
7
7
#include "hash-format.h"
8
 
#include "network.h"
 
8
#include "net.h"
9
9
#include "unichar.h"
10
10
#include "settings-parser.h"
11
11
#include "all-settings.h"
27
27
        const char *mail_attachment_dir;
28
28
        const char *mail_attachment_hash;
29
29
        uoff_t mail_attachment_min_size;
 
30
        const char *mail_attribute_dict;
30
31
        unsigned int mail_prefetch_count;
31
32
        const char *mail_cache_fields;
 
33
        const char *mail_always_cache_fields;
32
34
        const char *mail_never_cache_fields;
33
35
        unsigned int mail_cache_min_mail_count;
34
36
        unsigned int mailbox_idle_check_interval;
49
51
        const char *lock_method;
50
52
        const char *pop3_uidl_format;
51
53
 
 
54
        const char *ssl_client_ca_dir;
 
55
        const char *ssl_client_ca_file;
 
56
        const char *ssl_crypto_device;
 
57
 
52
58
        enum file_lock_method parsed_lock_method;
53
59
        enum fsync_mode parsed_fsync_mode;
54
60
};
65
71
        const char *list;
66
72
        bool subscriptions;
67
73
        bool ignore_on_failure;
 
74
        bool disabled;
68
75
 
69
 
        ARRAY_DEFINE(mailboxes, struct mailbox_settings *);
 
76
        ARRAY(struct mailbox_settings *) mailboxes;
70
77
        struct mail_user_settings *user_set;
71
78
};
72
79
struct mailbox_settings {
73
80
        const char *name;
74
81
        const char *autocreate;
75
82
        const char *special_use;
 
83
        const char *driver;
76
84
};
77
85
struct mail_user_settings {
78
86
        const char *base_dir;
95
103
 
96
104
        const char *mail_log_prefix;
97
105
 
98
 
        ARRAY_DEFINE(namespaces, struct mail_namespace_settings *);
99
 
        ARRAY_DEFINE(plugin_envs, const char *);
 
106
        ARRAY(struct mail_namespace_settings *) namespaces;
 
107
        ARRAY(const char *) plugin_envs;
100
108
};
101
109
/* ../../src/lib-storage/index/pop3c/pop3c-settings.h */
102
110
struct pop3c_settings {
104
112
        unsigned int pop3c_port;
105
113
 
106
114
        const char *pop3c_user;
 
115
        const char *pop3c_master_user;
107
116
        const char *pop3c_password;
108
117
 
109
118
        const char *pop3c_ssl;
110
 
        const char *pop3c_ssl_ca_dir;
111
119
        bool pop3c_ssl_verify;
112
120
 
113
121
        const char *pop3c_rawlog_dir;
114
 
        const char *ssl_crypto_device;
115
122
};
116
123
/* ../../src/lib-storage/index/mbox/mbox-settings.h */
117
124
struct mbox_settings {
135
142
/* <settings checks> */
136
143
enum imapc_features {
137
144
        IMAPC_FEATURE_RFC822_SIZE       = 0x01,
138
 
        IMAPC_FEATURE_GUID_FORCED       = 0x02
 
145
        IMAPC_FEATURE_GUID_FORCED       = 0x02,
 
146
        IMAPC_FEATURE_FETCH_HEADERS     = 0x04
139
147
};
140
148
/* </settings checks> */
141
149
struct imapc_settings {
147
155
        const char *imapc_password;
148
156
 
149
157
        const char *imapc_ssl;
150
 
        const char *imapc_ssl_ca_dir;
151
158
        bool imapc_ssl_verify;
152
159
 
153
160
        const char *imapc_features;
154
161
        const char *imapc_rawlog_dir;
155
162
        const char *imapc_list_prefix;
156
 
        const char *ssl_crypto_device;
 
163
        unsigned int imapc_max_idle_time;
157
164
 
158
165
        enum imapc_features parsed_features;
159
166
};
205
212
        const char *address;
206
213
        unsigned int port;
207
214
        bool ssl;
 
215
        bool reuse_port;
208
216
};
209
217
ARRAY_DEFINE_TYPE(inet_listener_settings, struct inet_listener_settings *);
210
218
struct service_settings {
243
251
        unsigned int process_limit_1:1;
244
252
};
245
253
ARRAY_DEFINE_TYPE(service_settings, struct service_settings *);
 
254
/* ../../src/lib-master/master-service-ssl-settings.h */
 
255
extern const struct setting_parser_info master_service_ssl_setting_parser_info;
 
256
struct master_service_ssl_settings {
 
257
        const char *ssl;
 
258
        const char *ssl_ca;
 
259
        const char *ssl_cert;
 
260
        const char *ssl_key;
 
261
        const char *ssl_key_password;
 
262
        const char *ssl_cipher_list;
 
263
        const char *ssl_protocols;
 
264
        const char *ssl_cert_username_field;
 
265
        const char *ssl_crypto_device;
 
266
        bool ssl_verify_client_cert;
 
267
        bool ssl_require_crl;
 
268
        bool verbose_ssl;
 
269
        bool ssl_prefer_server_ciphers;
 
270
};
246
271
/* ../../src/lib-master/master-service-settings.h */
247
272
extern const struct setting_parser_info master_service_setting_parser_info;
248
273
struct master_service_settings {
 
274
        const char *base_dir;
 
275
        const char *state_dir;
249
276
        const char *log_path;
250
277
        const char *info_log_path;
251
278
        const char *debug_log_path;
278
305
        const char *connect;
279
306
 
280
307
        unsigned int max_field_count;
281
 
        ARRAY_DEFINE(maps, struct dict_sql_map);
 
308
        ARRAY(struct dict_sql_map) maps;
282
309
};
283
310
/* ../../src/lib-storage/mail-storage-settings.c */
284
311
extern const struct setting_parser_info mailbox_setting_parser_info;
293
320
        bool uidl_format_ok;
294
321
        char c;
295
322
 
 
323
        if (set->mailbox_idle_check_interval == 0) {
 
324
                *error_r = "mailbox_idle_check_interval must not be 0";
 
325
                return FALSE;
 
326
        }
 
327
 
296
328
        if (strcmp(set->mail_fsync, "optimized") == 0)
297
329
                set->parsed_fsync_mode = FSYNC_MODE_OPTIMIZED;
298
330
        else if (strcmp(set->mail_fsync, "never") == 0)
366
398
                return FALSE;
367
399
        }
368
400
        hash_format_deinit_free(&format);
 
401
#ifndef CONFIG_BINARY
 
402
        if (*set->ssl_client_ca_dir != '\0' &&
 
403
            access(set->ssl_client_ca_dir, X_OK) < 0) {
 
404
                *error_r = t_strdup_printf(
 
405
                        "ssl_client_ca_dir: access(%s) failed: %m",
 
406
                        set->ssl_client_ca_dir);
 
407
                return FALSE;
 
408
        }
 
409
#endif
369
410
        return TRUE;
370
411
}
371
412
 
385
426
                        name);
386
427
                return FALSE;
387
428
        }
 
429
        if (!uni_utf8_str_is_valid(name)) {
 
430
                *error_r = t_strdup_printf("Namespace prefix not valid UTF8: %s",
 
431
                                           name);
 
432
                return FALSE;
 
433
        }
388
434
 
389
 
        if (ns->alias_for != NULL) {
 
435
        if (ns->alias_for != NULL && !ns->disabled) {
390
436
                if (array_is_created(&ns->user_set->namespaces)) {
391
437
                        namespaces = array_get(&ns->user_set->namespaces,
392
438
                                               &count);
507
553
        DEF(SET_STR_VARS, mail_attachment_dir),
508
554
        DEF(SET_STR, mail_attachment_hash),
509
555
        DEF(SET_SIZE, mail_attachment_min_size),
 
556
        DEF(SET_STR_VARS, mail_attribute_dict),
510
557
        DEF(SET_UINT, mail_prefetch_count),
511
558
        DEF(SET_STR, mail_cache_fields),
 
559
        DEF(SET_STR, mail_always_cache_fields),
512
560
        DEF(SET_STR, mail_never_cache_fields),
513
561
        DEF(SET_UINT, mail_cache_min_mail_count),
514
562
        DEF(SET_TIME, mailbox_idle_check_interval),
529
577
        DEF(SET_ENUM, lock_method),
530
578
        DEF(SET_STR, pop3_uidl_format),
531
579
 
 
580
        DEF(SET_STR, ssl_client_ca_dir),
 
581
        DEF(SET_STR, ssl_client_ca_file),
 
582
        DEF(SET_STR, ssl_crypto_device),
 
583
 
532
584
        SETTING_DEFINE_LIST_END
533
585
};
534
586
const struct mail_storage_settings mail_storage_default_settings = {
537
589
        .mail_attachment_dir = "",
538
590
        .mail_attachment_hash = "%{sha1}",
539
591
        .mail_attachment_min_size = 1024*128,
 
592
        .mail_attribute_dict = "",
540
593
        .mail_prefetch_count = 0,
541
594
        .mail_cache_fields = "flags",
 
595
        .mail_always_cache_fields = "",
542
596
        .mail_never_cache_fields = "imap.envelope",
543
597
        .mail_cache_min_mail_count = 0,
544
598
        .mailbox_idle_check_interval = 30,
555
609
        .mail_debug = FALSE,
556
610
        .mail_full_filesystem_access = FALSE,
557
611
        .maildir_stat_dirs = FALSE,
558
 
        .mail_shared_explicit_inbox = TRUE,
 
612
        .mail_shared_explicit_inbox = FALSE,
559
613
        .lock_method = "fcntl:flock:dotlock",
560
 
        .pop3_uidl_format = "%08Xu%08Xv"
 
614
        .pop3_uidl_format = "%08Xu%08Xv",
 
615
 
 
616
        .ssl_client_ca_dir = "",
 
617
        .ssl_client_ca_file = "",
 
618
        .ssl_crypto_device = ""
561
619
};
562
620
const struct setting_parser_info mail_storage_setting_parser_info = {
563
621
        .module_name = "mail",
579
637
        DEF(SET_STR, name),
580
638
        { SET_ENUM, "auto", offsetof(struct mailbox_settings, autocreate), NULL } ,
581
639
        DEF(SET_STR, special_use),
 
640
        DEF(SET_STR, driver),
582
641
 
583
642
        SETTING_DEFINE_LIST_END
584
643
};
587
646
        .autocreate = MAILBOX_SET_AUTO_NO":"
588
647
                MAILBOX_SET_AUTO_CREATE":"
589
648
                MAILBOX_SET_AUTO_SUBSCRIBE,
590
 
        .special_use = ""
 
649
        .special_use = "",
 
650
        .driver = ""
591
651
};
592
652
const struct setting_parser_info mailbox_setting_parser_info = {
593
653
        .defines = mailbox_setting_defines,
623
683
        DEF(SET_ENUM, list),
624
684
        DEF(SET_BOOL, subscriptions),
625
685
        DEF(SET_BOOL, ignore_on_failure),
 
686
        DEF(SET_BOOL, disabled),
626
687
 
627
688
        DEFLIST_UNIQUE(mailboxes, "mailbox", &mailbox_setting_parser_info),
628
689
 
641
702
        .list = "yes:no:children",
642
703
        .subscriptions = TRUE,
643
704
        .ignore_on_failure = FALSE,
 
705
        .disabled = FALSE,
644
706
 
645
707
        .mailboxes = ARRAY_INIT
646
708
};
740
802
                *error_r = "invalid pop3c_port";
741
803
                return FALSE;
742
804
        }
743
 
#ifndef CONFIG_BINARY
744
 
        if (*set->pop3c_ssl_ca_dir != '\0' &&
745
 
            access(set->pop3c_ssl_ca_dir, X_OK) < 0) {
746
 
                *error_r = t_strdup_printf(
747
 
                        "pop3c_ssl_ca_dir: access(%s) failed: %m",
748
 
                        set->pop3c_ssl_ca_dir);
749
 
                return FALSE;
750
 
        }
751
 
#endif
752
805
        return TRUE;
753
806
}
754
807
#undef DEF
759
812
        DEF(SET_UINT, pop3c_port),
760
813
 
761
814
        DEF(SET_STR_VARS, pop3c_user),
 
815
        DEF(SET_STR_VARS, pop3c_master_user),
762
816
        DEF(SET_STR, pop3c_password),
763
817
 
764
818
        DEF(SET_ENUM, pop3c_ssl),
765
 
        DEF(SET_STR, pop3c_ssl_ca_dir),
766
819
        DEF(SET_BOOL, pop3c_ssl_verify),
767
820
 
768
821
        DEF(SET_STR, pop3c_rawlog_dir),
769
 
        DEF(SET_STR, ssl_crypto_device),
770
822
 
771
823
        SETTING_DEFINE_LIST_END
772
824
};
775
827
        .pop3c_port = 110,
776
828
 
777
829
        .pop3c_user = "%u",
 
830
        .pop3c_master_user = "",
778
831
        .pop3c_password = "",
779
832
 
780
833
        .pop3c_ssl = "no:pop3s:starttls",
781
 
        .pop3c_ssl_ca_dir = "",
782
834
        .pop3c_ssl_verify = TRUE,
783
835
 
784
 
        .pop3c_rawlog_dir = "",
785
 
        .ssl_crypto_device = ""
 
836
        .pop3c_rawlog_dir = ""
786
837
};
787
838
static const struct setting_parser_info pop3c_setting_parser_info = {
788
839
        .module_name = "pop3c",
873
924
static const struct imapc_feature_list imapc_feature_list[] = {
874
925
        { "rfc822.size", IMAPC_FEATURE_RFC822_SIZE },
875
926
        { "guid-forced", IMAPC_FEATURE_GUID_FORCED },
 
927
        { "fetch-headers", IMAPC_FEATURE_FETCH_HEADERS },
876
928
        { NULL, 0 }
877
929
};
878
930
 
912
964
                *error_r = "invalid imapc_port";
913
965
                return FALSE;
914
966
        }
915
 
#ifndef CONFIG_BINARY
916
 
        if (*set->imapc_ssl_ca_dir != '\0' &&
917
 
            access(set->imapc_ssl_ca_dir, X_OK) < 0) {
918
 
                *error_r = t_strdup_printf(
919
 
                        "imapc_ssl_ca_dir: access(%s) failed: %m",
920
 
                        set->imapc_ssl_ca_dir);
 
967
        if (set->imapc_max_idle_time == 0) {
 
968
                *error_r = "imapc_max_idle_time must not be 0";
921
969
                return FALSE;
922
970
        }
923
 
#endif
924
971
        if (imapc_settings_parse_features(set, error_r) < 0)
925
972
                return FALSE;
926
973
        return TRUE;
937
984
        DEF(SET_STR, imapc_password),
938
985
 
939
986
        DEF(SET_ENUM, imapc_ssl),
940
 
        DEF(SET_STR, imapc_ssl_ca_dir),
941
987
        DEF(SET_BOOL, imapc_ssl_verify),
942
988
 
943
989
        DEF(SET_STR, imapc_features),
944
990
        DEF(SET_STR, imapc_rawlog_dir),
945
991
        DEF(SET_STR, imapc_list_prefix),
946
 
        DEF(SET_STR, ssl_crypto_device),
 
992
        DEF(SET_TIME, imapc_max_idle_time),
947
993
 
948
994
        SETTING_DEFINE_LIST_END
949
995
};
951
997
        .imapc_host = "",
952
998
        .imapc_port = 143,
953
999
 
954
 
        .imapc_user = "%u",
 
1000
        .imapc_user = "",
955
1001
        .imapc_master_user = "",
956
1002
        .imapc_password = "",
957
1003
 
958
1004
        .imapc_ssl = "no:imaps:starttls",
959
 
        .imapc_ssl_ca_dir = "",
960
1005
        .imapc_ssl_verify = TRUE,
961
1006
 
962
1007
        .imapc_features = "",
963
1008
        .imapc_rawlog_dir = "",
964
1009
        .imapc_list_prefix = "",
965
 
        .ssl_crypto_device = ""
 
1010
        .imapc_max_idle_time = 60*29
966
1011
};
967
1012
static const struct setting_parser_info imapc_setting_parser_info = {
968
1013
        .module_name = "imapc",
1005
1050
        .parent = &mail_user_setting_parser_info
1006
1051
};
1007
1052
/* ../../src/lib-settings/settings.c */
1008
 
/* ../../src/lib-master/master-service-settings.c */
1009
 
/* <settings checks> */
1010
 
static bool
1011
 
master_service_settings_check(void *_set, pool_t pool ATTR_UNUSED,
1012
 
                              const char **error_r ATTR_UNUSED)
1013
 
{
1014
 
        struct master_service_settings *set = _set;
1015
 
 
1016
 
        if (*set->log_path == '\0') {
1017
 
                /* default to syslog logging */
1018
 
                set->log_path = "syslog";
1019
 
        }
1020
 
        return TRUE;
1021
 
}
1022
 
/* </settings checks> */
1023
 
#undef DEF
1024
 
#define DEF(type, name) \
1025
 
        { type, #name, offsetof(struct master_service_settings, name), NULL }
1026
 
static const struct setting_define master_service_setting_defines[] = {
1027
 
        DEF(SET_STR, log_path),
1028
 
        DEF(SET_STR, info_log_path),
1029
 
        DEF(SET_STR, debug_log_path),
1030
 
        DEF(SET_STR, log_timestamp),
1031
 
        DEF(SET_STR, syslog_facility),
1032
 
        DEF(SET_SIZE, config_cache_size),
1033
 
        DEF(SET_BOOL, version_ignore),
1034
 
        DEF(SET_BOOL, shutdown_clients),
1035
 
        DEF(SET_BOOL, verbose_proctitle),
1036
 
 
1037
 
        SETTING_DEFINE_LIST_END
1038
 
};
1039
 
static const struct master_service_settings master_service_default_settings = {
1040
 
        .log_path = "syslog",
1041
 
        .info_log_path = "",
1042
 
        .debug_log_path = "",
1043
 
        .log_timestamp = DEFAULT_FAILURE_STAMP_FORMAT,
1044
 
        .syslog_facility = "mail",
1045
 
        .config_cache_size = 1024*1024,
1046
 
        .version_ignore = FALSE,
1047
 
        .shutdown_clients = TRUE,
1048
 
        .verbose_proctitle = FALSE
1049
 
};
1050
 
const struct setting_parser_info master_service_setting_parser_info = {
1051
 
        .module_name = "master",
1052
 
        .defines = master_service_setting_defines,
1053
 
        .defaults = &master_service_default_settings,
1054
 
 
1055
 
        .type_offset = (size_t)-1,
1056
 
        .struct_size = sizeof(struct master_service_settings),
1057
 
 
1058
 
        .parent_offset = (size_t)-1,
1059
 
        .check_func = master_service_settings_check
1060
 
};
1061
1053
/* ../../src/lib-lda/lda-settings.c */
1062
1054
#undef DEF
1063
1055
#undef DEFLIST
1066
1058
#define DEFLIST(field, name, defines) \
1067
1059
        { SET_DEFLIST, name, offsetof(struct lda_settings, field), defines }
1068
1060
static const struct setting_define lda_setting_defines[] = {
1069
 
        DEF(SET_STR, postmaster_address),
 
1061
        DEF(SET_STR_VARS, postmaster_address),
1070
1062
        DEF(SET_STR, hostname),
1071
 
        DEF(SET_STR, submission_host),
1072
 
        DEF(SET_STR, sendmail_path),
 
1063
        DEF(SET_STR_VARS, submission_host),
 
1064
        DEF(SET_STR_VARS, sendmail_path),
1073
1065
        DEF(SET_STR, rejection_subject),
1074
1066
        DEF(SET_STR, rejection_reason),
1075
1067
        DEF(SET_STR, deliver_log_format),
1131
1123
/* ../../src/ssl-params/ssl-params-settings.h */
1132
1124
struct ssl_params_settings {
1133
1125
        unsigned int ssl_parameters_regenerate;
 
1126
        unsigned int ssl_dh_parameters_length;
1134
1127
};
1135
1128
/* ../../src/replication/replicator/replicator-settings.h */
1136
1129
extern const struct setting_parser_info replicator_setting_parser_info;
1137
1130
struct replicator_settings {
1138
1131
        const char *auth_socket_path;
1139
1132
        const char *doveadm_socket_path;
 
1133
        const char *replication_dsync_parameters;
1140
1134
 
1141
1135
        unsigned int replication_full_sync_interval;
1142
1136
        unsigned int replication_max_conns;
1168
1162
        const char *pop3_client_workarounds;
1169
1163
        const char *pop3_logout_format;
1170
1164
        const char *pop3_uidl_duplicates;
 
1165
        const char *pop3_deleted_flag;
1171
1166
 
1172
1167
        enum pop3_client_workarounds parsed_workarounds;
1173
1168
};
1177
1172
extern const struct setting_parser_info master_setting_parser_info;
1178
1173
struct master_settings {
1179
1174
        const char *base_dir;
 
1175
        const char *state_dir;
1180
1176
        const char *libexec_dir;
1181
1177
        const char *instance_name;
1182
1178
        const char *import_environment;
1208
1204
        const char *login_access_sockets;
1209
1205
        const char *director_username_hash;
1210
1206
 
1211
 
        const char *ssl;
1212
 
        const char *ssl_ca;
1213
 
        const char *ssl_cert;
1214
 
        const char *ssl_key;
1215
 
        const char *ssl_key_password;
1216
 
        const char *ssl_cipher_list;
1217
 
        const char *ssl_protocols;
1218
 
        const char *ssl_cert_username_field;
1219
1207
        const char *ssl_client_cert;
1220
1208
        const char *ssl_client_key;
1221
 
        const char *ssl_crypto_device;
1222
 
        bool ssl_verify_client_cert;
1223
1209
        bool ssl_require_crl;
1224
1210
        bool auth_ssl_require_client_cert;
1225
1211
        bool auth_ssl_username_from_cert;
1226
 
        bool verbose_ssl;
1227
1212
 
1228
1213
        bool disable_plaintext_auth;
1229
1214
        bool auth_verbose;
1241
1226
struct lmtp_settings {
1242
1227
        bool lmtp_proxy;
1243
1228
        bool lmtp_save_to_detail_mailbox;
 
1229
        bool lmtp_rcpt_check_quota;
 
1230
        const char *lmtp_address_translate;
1244
1231
        const char *login_greeting;
 
1232
        const char *login_trusted_networks;
1245
1233
};
1246
1234
/* ../../src/imap/imap-settings.h */
1247
1235
extern const struct setting_parser_info imap_setting_parser_info;
1263
1251
        const char *imap_logout_format;
1264
1252
        const char *imap_id_send;
1265
1253
        const char *imap_id_log;
 
1254
        bool imap_metadata;
 
1255
 
 
1256
        /* imap urlauth: */
 
1257
        const char *imap_urlauth_host;
 
1258
        unsigned int imap_urlauth_port;
1266
1259
 
1267
1260
        enum imap_client_workarounds parsed_workarounds;
1268
1261
};
 
1262
/* ../../src/imap-urlauth/imap-urlauth-worker-settings.h */
 
1263
extern const struct setting_parser_info imap_urlauth_worker_setting_parser_info;
 
1264
struct imap_urlauth_worker_settings {
 
1265
        bool verbose_proctitle;
 
1266
 
 
1267
        /* imap_urlauth: */
 
1268
        const char *imap_urlauth_host;
 
1269
        unsigned int imap_urlauth_port;
 
1270
};
 
1271
/* ../../src/imap-urlauth/imap-urlauth-settings.h */
 
1272
extern const struct setting_parser_info imap_urlauth_setting_parser_info;
 
1273
struct imap_urlauth_settings {
 
1274
        const char *base_dir;
 
1275
 
 
1276
        bool mail_debug;
 
1277
 
 
1278
        bool verbose_proctitle;
 
1279
 
 
1280
        /* imap_urlauth: */
 
1281
        const char *imap_urlauth_logout_format;
 
1282
 
 
1283
        const char *imap_urlauth_submit_user;
 
1284
        const char *imap_urlauth_stream_user;
 
1285
};
 
1286
/* ../../src/imap-urlauth/imap-urlauth-login-settings.h */
 
1287
extern const struct setting_parser_info *imap_urlauth_login_setting_roots[];
1269
1288
/* ../../src/imap-login/imap-login-settings.h */
1270
1289
extern const struct setting_parser_info *imap_login_setting_roots[];
1271
1290
struct imap_login_settings {
1277
1296
extern const struct setting_parser_info doveadm_setting_parser_info;
1278
1297
struct doveadm_settings {
1279
1298
        const char *base_dir;
 
1299
        const char *libexec_dir;
1280
1300
        const char *mail_plugins;
1281
1301
        const char *mail_plugin_dir;
 
1302
        const char *auth_socket_path;
1282
1303
        const char *doveadm_socket_path;
1283
1304
        unsigned int doveadm_worker_count;
1284
 
        unsigned int doveadm_proxy_port;
 
1305
        unsigned int doveadm_port;
1285
1306
        const char *doveadm_password;
1286
1307
        const char *doveadm_allowed_commands;
1287
1308
        const char *dsync_alt_char;
1288
1309
        const char *dsync_remote_cmd;
 
1310
        const char *ssl_client_ca_dir;
 
1311
        const char *ssl_client_ca_file;
1289
1312
 
1290
 
        ARRAY_DEFINE(plugin_envs, const char *);
 
1313
        ARRAY(const char *) plugin_envs;
1291
1314
};
1292
1315
/* ../../src/director/director-settings.h */
1293
1316
extern const struct setting_parser_info director_setting_parser_info;
1305
1328
struct dict_settings {
1306
1329
        const char *base_dir;
1307
1330
        const char *dict_db_config;
1308
 
        ARRAY_DEFINE(dicts, const char *);
 
1331
        ARRAY(const char *) dicts;
1309
1332
};
1310
1333
/* ../../src/auth/auth-settings.h */
1311
1334
extern const struct setting_parser_info auth_setting_parser_info;
1314
1337
        const char *args;
1315
1338
        const char *default_fields;
1316
1339
        const char *override_fields;
 
1340
        const char *skip;
 
1341
        const char *result_success;
 
1342
        const char *result_failure;
 
1343
        const char *result_internalfail;
1317
1344
        bool deny;
1318
1345
        bool pass;
1319
1346
        bool master;
1341
1368
        const char *winbind_helper_path;
1342
1369
        const char *proxy_self;
1343
1370
        unsigned int failure_delay;
1344
 
        unsigned int first_valid_uid;
1345
 
        unsigned int last_valid_uid;
1346
1371
 
1347
1372
        bool verbose, debug, debug_passwords;
1348
1373
        const char *verbose_passwords;
1352
1377
 
1353
1378
        unsigned int worker_max_count;
1354
1379
 
1355
 
        ARRAY_DEFINE(passdbs, struct auth_passdb_settings *);
1356
 
        ARRAY_DEFINE(userdbs, struct auth_userdb_settings *);
 
1380
        /* settings that don't have auth_ prefix: */
 
1381
        ARRAY(struct auth_passdb_settings *) passdbs;
 
1382
        ARRAY(struct auth_userdb_settings *) userdbs;
1357
1383
 
1358
1384
        const char *base_dir;
1359
1385
        bool verbose_proctitle;
 
1386
        unsigned int first_valid_uid;
 
1387
        unsigned int last_valid_uid;
1360
1388
 
1361
1389
        /* generated: */
1362
1390
        char username_chars_map[256];
1430
1458
        .process_limit = 1,
1431
1459
        .client_limit = 0,
1432
1460
        .service_count = 0,
1433
 
        .idle_kill = -1U,
 
1461
        .idle_kill = UINT_MAX,
1434
1462
        .vsz_limit = (uoff_t)-1,
1435
1463
 
1436
1464
        .unix_listeners = { { &stats_unix_listeners_buf,
1474
1502
/* ../../src/ssl-params/ssl-params-settings.c */
1475
1503
/* <settings checks> */
1476
1504
static struct file_listener_settings ssl_params_unix_listeners_array[] = {
 
1505
        { "ssl-params", 0666, "", "" },
1477
1506
        { "login/ssl-params", 0666, "", "" }
1478
1507
};
1479
1508
static struct file_listener_settings *ssl_params_unix_listeners[] = {
1480
 
        &ssl_params_unix_listeners_array[0]
 
1509
        &ssl_params_unix_listeners_array[0],
 
1510
        &ssl_params_unix_listeners_array[1]
1481
1511
};
1482
1512
static buffer_t ssl_params_unix_listeners_buf = {
1483
1513
        ssl_params_unix_listeners, sizeof(ssl_params_unix_listeners), { 0, }
1517
1547
        { type, #name, offsetof(struct ssl_params_settings, name), NULL }
1518
1548
static const struct setting_define ssl_params_setting_defines[] = {
1519
1549
        DEF(SET_TIME, ssl_parameters_regenerate),
 
1550
        DEF(SET_UINT, ssl_dh_parameters_length),
1520
1551
 
1521
1552
        SETTING_DEFINE_LIST_END
1522
1553
};
1523
1554
static const struct ssl_params_settings ssl_params_default_settings = {
1524
 
        .ssl_parameters_regenerate = 3600*24*7
 
1555
        .ssl_parameters_regenerate = 0,
 
1556
        .ssl_dh_parameters_length = 1024
1525
1557
};
1526
1558
const struct setting_parser_info ssl_params_setting_parser_info = {
1527
1559
        .module_name = "ssl-params",
1536
1568
/* ../../src/replication/replicator/replicator-settings.c */
1537
1569
/* <settings checks> */
1538
1570
static struct file_listener_settings replicator_unix_listeners_array[] = {
1539
 
        { "replicator", 0600, "$default_internal_user", "" }
 
1571
        { "replicator", 0600, "$default_internal_user", "" },
 
1572
        { "replicator-doveadm", 0, "$default_internal_user", "" }
1540
1573
};
1541
1574
static struct file_listener_settings *replicator_unix_listeners[] = {
1542
 
        &replicator_unix_listeners_array[0]
 
1575
        &replicator_unix_listeners_array[0],
 
1576
        &replicator_unix_listeners_array[1]
1543
1577
};
1544
1578
static buffer_t replicator_unix_listeners_buf = {
1545
1579
        replicator_unix_listeners, sizeof(replicator_unix_listeners), { 0, }
1562
1596
        .process_limit = 1,
1563
1597
        .client_limit = 0,
1564
1598
        .service_count = 0,
1565
 
        .idle_kill = -1U,
 
1599
        .idle_kill = UINT_MAX,
1566
1600
        .vsz_limit = (uoff_t)-1,
1567
1601
 
1568
1602
        .unix_listeners = { { &replicator_unix_listeners_buf,
1576
1610
static const struct setting_define replicator_setting_defines[] = {
1577
1611
        DEF(SET_STR, auth_socket_path),
1578
1612
        DEF(SET_STR, doveadm_socket_path),
 
1613
        DEF(SET_STR, replication_dsync_parameters),
1579
1614
 
1580
1615
        DEF(SET_TIME, replication_full_sync_interval),
1581
1616
        DEF(SET_UINT, replication_max_conns),
1585
1620
const struct replicator_settings replicator_default_settings = {
1586
1621
        .auth_socket_path = "auth-userdb",
1587
1622
        .doveadm_socket_path = "doveadm-server",
 
1623
        .replication_dsync_parameters = "-d -N -l 30 -U",
1588
1624
 
1589
 
        .replication_full_sync_interval = 60*60*12,
 
1625
        .replication_full_sync_interval = 60*60*24,
1590
1626
        .replication_max_conns = 10
1591
1627
};
1592
1628
const struct setting_parser_info replicator_setting_parser_info = {
1774
1810
        DEF(SET_STR, pop3_client_workarounds),
1775
1811
        DEF(SET_STR, pop3_logout_format),
1776
1812
        DEF(SET_ENUM, pop3_uidl_duplicates),
 
1813
        DEF(SET_STR, pop3_deleted_flag),
1777
1814
 
1778
1815
        SETTING_DEFINE_LIST_END
1779
1816
};
1788
1825
        .pop3_fast_size_lookups = FALSE,
1789
1826
        .pop3_client_workarounds = "",
1790
1827
        .pop3_logout_format = "top=%t/%p, retr=%r/%b, del=%d/%m, size=%s",
1791
 
        .pop3_uidl_duplicates = "allow:rename"
 
1828
        .pop3_uidl_duplicates = "allow:rename",
 
1829
        .pop3_deleted_flag = ""
1792
1830
};
1793
1831
static const struct setting_parser_info *pop3_setting_dependencies[] = {
1794
1832
        &mail_user_setting_parser_info,
1810
1848
/* ../../src/pop3-login/pop3-login-settings.c */
1811
1849
/* <settings checks> */
1812
1850
static struct inet_listener_settings pop3_login_inet_listeners_array[] = {
1813
 
        { "pop3", "", 110, FALSE },
1814
 
        { "pop3s", "", 995, TRUE }
 
1851
        { .name = "pop3", .address = "", .port = 110 },
 
1852
        { .name = "pop3s", .address = "", .port = 995, .ssl = TRUE }
1815
1853
};
1816
1854
static struct inet_listener_settings *pop3_login_inet_listeners[] = {
1817
1855
        &pop3_login_inet_listeners_array[0],
2046
2084
        const struct service_settings *default_service;
2047
2085
#else
2048
2086
        rlim_t fd_limit;
2049
 
        const char *max_client_limit_source = "default_client_count";
 
2087
        const char *max_client_limit_source = "default_client_limit";
2050
2088
        unsigned int max_client_limit = set->default_client_limit;
2051
2089
#endif
2052
2090
 
2127
2165
        for (i = 0; i < count; i++) {
2128
2166
                struct service_settings *service = services[i];
2129
2167
 
2130
 
                if (*service->executable == '\0') {
2131
 
                        *error_r = t_strdup_printf("service(%s): "
2132
 
                                "executable is empty", service->name);
2133
 
                        return FALSE;
 
2168
                if (*service->protocol != '\0' &&
 
2169
                    !str_array_find((const char **)set->protocols_split,
 
2170
                                    service->protocol)) {
 
2171
                        /* protocol not enabled, ignore its settings */
 
2172
                        continue;
2134
2173
                }
2135
 
                if (*service->executable != '/') {
 
2174
 
 
2175
                if (*service->executable != '/' &&
 
2176
                    *service->executable != '\0') {
2136
2177
                        service->executable =
2137
2178
                                p_strconcat(pool, set->libexec_dir, "/",
2138
2179
                                            service->executable, NULL);
2181
2222
                }
2182
2223
#endif
2183
2224
 
2184
 
                if (*service->protocol != '\0' &&
2185
 
                    str_array_find((const char **)set->protocols_split,
2186
 
                                   service->protocol)) {
 
2225
                if (*service->protocol != '\0') {
2187
2226
                        /* each imap/pop3/lmtp process can use up a connection,
2188
2227
                           although if service_count=1 it's only temporary */
2189
2228
                        if (service->service_count != 1 ||
2274
2313
        DEF(SET_STR, address),
2275
2314
        DEF(SET_UINT, port),
2276
2315
        DEF(SET_BOOL, ssl),
 
2316
        DEF(SET_BOOL, reuse_port),
2277
2317
 
2278
2318
        SETTING_DEFINE_LIST_END
2279
2319
};
2281
2321
        .name = "",
2282
2322
        .address = "",
2283
2323
        .port = 0,
2284
 
        .ssl = FALSE
 
2324
        .ssl = FALSE,
 
2325
        .reuse_port = FALSE
2285
2326
};
2286
2327
static const struct setting_parser_info inet_listener_setting_parser_info = {
2287
2328
        .defines = inet_listener_setting_defines,
2373
2414
        { SET_DEFLIST_UNIQUE, name, offsetof(struct master_settings, field), defines }
2374
2415
static const struct setting_define master_setting_defines[] = {
2375
2416
        DEF(SET_STR, base_dir),
 
2417
        DEF(SET_STR, state_dir),
2376
2418
        DEF(SET_STR, libexec_dir),
2377
2419
        DEF(SET_STR, instance_name),
2378
2420
        DEF(SET_STR, import_environment),
2399
2441
};
2400
2442
struct master_settings master_default_settings = {
2401
2443
        .base_dir = PKG_RUNDIR,
 
2444
        .state_dir = PKG_STATEDIR,
2402
2445
        .libexec_dir = PKG_LIBEXECDIR,
2403
2446
        .instance_name = PACKAGE,
2404
 
        .import_environment = "TZ" ENV_SYSTEMD ENV_GDB,
 
2447
        .import_environment = "TZ DEBUG_OUTOFMEM" ENV_SYSTEMD ENV_GDB,
2405
2448
        .protocols = "imap pop3 lmtp",
2406
2449
        .listen = "*, ::",
2407
2450
        .ssl = "yes:no:required",
2440
2483
};
2441
2484
/* ../../src/login-common/login-settings.c */
2442
2485
/* <settings checks> */
2443
 
static int ssl_settings_check(void *_set ATTR_UNUSED, const char **error_r)
2444
 
{
2445
 
        struct login_settings *set = _set;
2446
 
 
2447
 
#ifndef HAVE_SSL
2448
 
        *error_r = t_strdup_printf("SSL support not compiled in but ssl=%s",
2449
 
                                   set->ssl);
2450
 
        return FALSE;
2451
 
#else
2452
 
        if (*set->ssl_cert == '\0') {
2453
 
                *error_r = "ssl enabled, but ssl_cert not set";
2454
 
                return FALSE;
2455
 
        }
2456
 
        if (*set->ssl_key == '\0') {
2457
 
                *error_r = "ssl enabled, but ssl_key not set";
2458
 
                return FALSE;
2459
 
        }
2460
 
        if (set->ssl_verify_client_cert && *set->ssl_ca == '\0') {
2461
 
                *error_r = "ssl_verify_client_cert set, but ssl_ca not";
2462
 
                return FALSE;
2463
 
        }
2464
 
        return TRUE;
2465
 
#endif
2466
 
}
2467
 
 
2468
 
static bool login_settings_check(void *_set, pool_t pool, const char **error_r)
 
2486
static bool login_settings_check(void *_set, pool_t pool,
 
2487
                                 const char **error_r ATTR_UNUSED)
2469
2488
{
2470
2489
        struct login_settings *set = _set;
2471
2490
 
2472
2491
        set->log_format_elements_split =
2473
2492
                p_strsplit(pool, set->login_log_format_elements, " ");
2474
2493
 
2475
 
        if (set->auth_ssl_require_client_cert ||
2476
 
            set->auth_ssl_username_from_cert) {
2477
 
                /* if we require valid cert, make sure we also ask for it */
2478
 
                set->ssl_verify_client_cert = TRUE;
2479
 
        }
2480
 
 
2481
2494
        if (set->auth_debug_passwords)
2482
2495
                set->auth_debug = TRUE;
2483
2496
        if (set->auth_debug)
2484
2497
                set->auth_verbose = TRUE;
2485
 
 
2486
 
        if (strcmp(set->ssl, "no") == 0) {
2487
 
                /* disabled */
2488
 
        } else if (strcmp(set->ssl, "yes") == 0) {
2489
 
                if (!ssl_settings_check(set, error_r))
2490
 
                        return FALSE;
2491
 
        } else if (strcmp(set->ssl, "required") == 0) {
2492
 
                if (!ssl_settings_check(set, error_r))
2493
 
                        return FALSE;
2494
 
                set->disable_plaintext_auth = TRUE;
2495
 
        } else {
2496
 
                *error_r = t_strdup_printf("Unknown ssl setting value: %s",
2497
 
                                           set->ssl);
2498
 
                return FALSE;
2499
 
        }
2500
2498
        return TRUE;
2501
2499
}
2502
2500
/* </settings checks> */
2511
2509
        DEF(SET_STR, login_access_sockets),
2512
2510
        DEF(SET_STR, director_username_hash),
2513
2511
 
2514
 
        DEF(SET_ENUM, ssl),
2515
 
        DEF(SET_STR, ssl_ca),
2516
 
        DEF(SET_STR, ssl_cert),
2517
 
        DEF(SET_STR, ssl_key),
2518
 
        DEF(SET_STR, ssl_key_password),
2519
 
        DEF(SET_STR, ssl_cipher_list),
2520
 
        DEF(SET_STR, ssl_protocols),
2521
 
        DEF(SET_STR, ssl_cert_username_field),
2522
2512
        DEF(SET_STR, ssl_client_cert),
2523
2513
        DEF(SET_STR, ssl_client_key),
2524
 
        DEF(SET_STR, ssl_crypto_device),
2525
 
        DEF(SET_BOOL, ssl_verify_client_cert),
2526
2514
        DEF(SET_BOOL, ssl_require_crl),
2527
2515
        DEF(SET_BOOL, auth_ssl_require_client_cert),
2528
2516
        DEF(SET_BOOL, auth_ssl_username_from_cert),
2529
 
        DEF(SET_BOOL, verbose_ssl),
2530
2517
 
2531
2518
        DEF(SET_BOOL, disable_plaintext_auth),
2532
2519
        DEF(SET_BOOL, auth_verbose),
2545
2532
        .login_access_sockets = "",
2546
2533
        .director_username_hash = "%u",
2547
2534
 
2548
 
        .ssl = "yes:no:required",
2549
 
        .ssl_ca = "",
2550
 
        .ssl_cert = "",
2551
 
        .ssl_key = "",
2552
 
        .ssl_key_password = "",
2553
 
        .ssl_cipher_list = "ALL:!LOW:!SSLv2:!EXP:!aNULL",
2554
 
        .ssl_protocols = "!SSLv2",
2555
 
        .ssl_cert_username_field = "commonName",
2556
2535
        .ssl_client_cert = "",
2557
2536
        .ssl_client_key = "",
2558
 
        .ssl_crypto_device = "",
2559
 
        .ssl_verify_client_cert = FALSE,
2560
2537
        .ssl_require_crl = TRUE,
2561
2538
        .auth_ssl_require_client_cert = FALSE,
2562
2539
        .auth_ssl_username_from_cert = FALSE,
2563
 
        .verbose_ssl = FALSE,
2564
2540
 
2565
2541
        .disable_plaintext_auth = TRUE,
2566
2542
        .auth_verbose = FALSE,
2611
2587
        .process_limit = 1,
2612
2588
        .client_limit = 0,
2613
2589
        .service_count = 0,
2614
 
        .idle_kill = -1U,
 
2590
        .idle_kill = UINT_MAX,
2615
2591
        .vsz_limit = (uoff_t)-1,
2616
2592
 
2617
2593
        .unix_listeners = { { &log_unix_listeners_buf,
2664
2640
static const struct setting_define lmtp_setting_defines[] = {
2665
2641
        DEF(SET_BOOL, lmtp_proxy),
2666
2642
        DEF(SET_BOOL, lmtp_save_to_detail_mailbox),
 
2643
        DEF(SET_BOOL, lmtp_rcpt_check_quota),
 
2644
        DEF(SET_STR, lmtp_address_translate),
2667
2645
        DEF(SET_STR_VARS, login_greeting),
 
2646
        DEF(SET_STR, login_trusted_networks),
2668
2647
 
2669
2648
        SETTING_DEFINE_LIST_END
2670
2649
};
2671
2650
static const struct lmtp_settings lmtp_default_settings = {
2672
2651
        .lmtp_proxy = FALSE,
2673
2652
        .lmtp_save_to_detail_mailbox = FALSE,
2674
 
        .login_greeting = PACKAGE_NAME" ready."
 
2653
        .lmtp_rcpt_check_quota = FALSE,
 
2654
        .lmtp_address_translate = "",
 
2655
        .login_greeting = PACKAGE_NAME" ready.",
 
2656
        .login_trusted_networks = ""
2675
2657
};
2676
2658
static const struct setting_parser_info *lmtp_setting_dependencies[] = {
2677
2659
        &lda_setting_parser_info,
2907
2889
        DEF(SET_STR, imap_logout_format),
2908
2890
        DEF(SET_STR, imap_id_send),
2909
2891
        DEF(SET_STR, imap_id_log),
 
2892
        DEF(SET_BOOL, imap_metadata),
 
2893
 
 
2894
        DEF(SET_STR, imap_urlauth_host),
 
2895
        DEF(SET_UINT, imap_urlauth_port),
2910
2896
 
2911
2897
        SETTING_DEFINE_LIST_END
2912
2898
};
2921
2907
        .imap_capability = "",
2922
2908
        .imap_client_workarounds = "",
2923
2909
        .imap_logout_format = "in=%i out=%o",
2924
 
        .imap_id_send = "",
2925
 
        .imap_id_log = ""
 
2910
        .imap_id_send = "name *",
 
2911
        .imap_id_log = "",
 
2912
        .imap_metadata = FALSE,
 
2913
 
 
2914
        .imap_urlauth_host = "",
 
2915
        .imap_urlauth_port = 143
2926
2916
};
2927
2917
static const struct setting_parser_info *imap_setting_dependencies[] = {
2928
2918
        &mail_user_setting_parser_info,
2941
2931
        .check_func = imap_settings_verify,
2942
2932
        .dependencies = imap_setting_dependencies
2943
2933
};
 
2934
/* ../../src/imap-urlauth/imap-urlauth-worker-settings.c */
 
2935
/* <settings checks> */
 
2936
static struct file_listener_settings imap_urlauth_worker_unix_listeners_array[] = {
 
2937
        { "imap-urlauth-worker", 0600, "$default_internal_user", "" }
 
2938
};
 
2939
static struct file_listener_settings *imap_urlauth_worker_unix_listeners[] = {
 
2940
        &imap_urlauth_worker_unix_listeners_array[0]
 
2941
};
 
2942
static buffer_t imap_urlauth_worker_unix_listeners_buf = {
 
2943
        imap_urlauth_worker_unix_listeners, sizeof(imap_urlauth_worker_unix_listeners), { 0, }
 
2944
};
 
2945
/* </settings checks> */
 
2946
struct service_settings imap_urlauth_worker_service_settings = {
 
2947
        .name = "imap-urlauth-worker",
 
2948
        .protocol = "imap",
 
2949
        .type = "",
 
2950
        .executable = "imap-urlauth-worker",
 
2951
        .user = "",
 
2952
        .group = "",
 
2953
        .privileged_group = "",
 
2954
        .extra_groups = "",
 
2955
        .chroot = "",
 
2956
 
 
2957
        .drop_priv_before_exec = FALSE,
 
2958
 
 
2959
        .process_min_avail = 0,
 
2960
        .process_limit = 1024,
 
2961
        .client_limit = 1,
 
2962
        .service_count = 1,
 
2963
        .idle_kill = 0,
 
2964
        .vsz_limit = (uoff_t)-1,
 
2965
 
 
2966
        .unix_listeners = { { &imap_urlauth_worker_unix_listeners_buf,
 
2967
                              sizeof(imap_urlauth_worker_unix_listeners[0]) } },
 
2968
        .fifo_listeners = ARRAY_INIT,
 
2969
        .inet_listeners = ARRAY_INIT
 
2970
};
 
2971
#undef DEF
 
2972
#define DEF(type, name) \
 
2973
        { type, #name, offsetof(struct imap_urlauth_worker_settings, name), NULL }
 
2974
static const struct setting_define imap_urlauth_worker_setting_defines[] = {
 
2975
        DEF(SET_BOOL, verbose_proctitle),
 
2976
 
 
2977
        DEF(SET_STR, imap_urlauth_host),
 
2978
        DEF(SET_UINT, imap_urlauth_port),
 
2979
 
 
2980
        SETTING_DEFINE_LIST_END
 
2981
};
 
2982
const struct imap_urlauth_worker_settings imap_urlauth_worker_default_settings = {
 
2983
        .verbose_proctitle = FALSE,
 
2984
 
 
2985
        .imap_urlauth_host = "",
 
2986
        .imap_urlauth_port = 143
 
2987
};
 
2988
static const struct setting_parser_info *imap_urlauth_worker_setting_dependencies[] = {
 
2989
        &mail_user_setting_parser_info,
 
2990
        NULL
 
2991
};
 
2992
const struct setting_parser_info imap_urlauth_worker_setting_parser_info = {
 
2993
        .module_name = "imap-urlauth-worker",
 
2994
        .defines = imap_urlauth_worker_setting_defines,
 
2995
        .defaults = &imap_urlauth_worker_default_settings,
 
2996
 
 
2997
        .type_offset = (size_t)-1,
 
2998
        .struct_size = sizeof(struct imap_urlauth_worker_settings),
 
2999
 
 
3000
        .parent_offset = (size_t)-1,
 
3001
 
 
3002
        .dependencies = imap_urlauth_worker_setting_dependencies
 
3003
};
 
3004
/* ../../src/imap-urlauth/imap-urlauth-settings.c */
 
3005
/* <settings checks> */
 
3006
static struct file_listener_settings imap_urlauth_unix_listeners_array[] = {
 
3007
        { "token-login/imap-urlauth", 0666, "", "" }
 
3008
};
 
3009
static struct file_listener_settings *imap_urlauth_unix_listeners[] = {
 
3010
        &imap_urlauth_unix_listeners_array[0]
 
3011
};
 
3012
static buffer_t imap_urlauth_unix_listeners_buf = {
 
3013
        imap_urlauth_unix_listeners, sizeof(imap_urlauth_unix_listeners), { 0, }
 
3014
};
 
3015
/* </settings checks> */
 
3016
struct service_settings imap_urlauth_service_settings = {
 
3017
        .name = "imap-urlauth",
 
3018
        .protocol = "imap",
 
3019
        .type = "",
 
3020
        .executable = "imap-urlauth",
 
3021
        .user = "$default_internal_user",
 
3022
        .group = "",
 
3023
        .privileged_group = "",
 
3024
        .extra_groups = "",
 
3025
        .chroot = "",
 
3026
 
 
3027
        .drop_priv_before_exec = FALSE,
 
3028
 
 
3029
        .process_min_avail = 0,
 
3030
        .process_limit = 1024,
 
3031
        .client_limit = 1,
 
3032
        .service_count = 1,
 
3033
        .idle_kill = 0,
 
3034
        .vsz_limit = (uoff_t)-1,
 
3035
 
 
3036
        .unix_listeners = { { &imap_urlauth_unix_listeners_buf,
 
3037
                              sizeof(imap_urlauth_unix_listeners[0]) } },
 
3038
        .fifo_listeners = ARRAY_INIT,
 
3039
        .inet_listeners = ARRAY_INIT
 
3040
};
 
3041
#undef DEF
 
3042
#define DEF(type, name) \
 
3043
        { type, #name, offsetof(struct imap_urlauth_settings, name), NULL }
 
3044
static const struct setting_define imap_urlauth_setting_defines[] = {
 
3045
        DEF(SET_STR, base_dir),
 
3046
 
 
3047
        DEF(SET_BOOL, mail_debug),
 
3048
 
 
3049
        DEF(SET_BOOL, verbose_proctitle),
 
3050
 
 
3051
        DEF(SET_STR, imap_urlauth_logout_format),
 
3052
        DEF(SET_STR, imap_urlauth_submit_user),
 
3053
        DEF(SET_STR, imap_urlauth_stream_user),
 
3054
 
 
3055
        SETTING_DEFINE_LIST_END
 
3056
};
 
3057
const struct imap_urlauth_settings imap_urlauth_default_settings = {
 
3058
        .base_dir = PKG_RUNDIR,
 
3059
  .mail_debug = FALSE,
 
3060
 
 
3061
        .verbose_proctitle = FALSE,
 
3062
 
 
3063
        .imap_urlauth_logout_format = "in=%i out=%o",
 
3064
        .imap_urlauth_submit_user = NULL,
 
3065
        .imap_urlauth_stream_user = NULL
 
3066
};
 
3067
static const struct setting_parser_info *imap_urlauth_setting_dependencies[] = {
 
3068
        NULL
 
3069
};
 
3070
const struct setting_parser_info imap_urlauth_setting_parser_info = {
 
3071
        .module_name = "imap-urlauth",
 
3072
        .defines = imap_urlauth_setting_defines,
 
3073
        .defaults = &imap_urlauth_default_settings,
 
3074
 
 
3075
        .type_offset = (size_t)-1,
 
3076
        .struct_size = sizeof(struct imap_urlauth_settings),
 
3077
 
 
3078
        .parent_offset = (size_t)-1,
 
3079
 
 
3080
        .dependencies = imap_urlauth_setting_dependencies
 
3081
};
 
3082
/* ../../src/imap-urlauth/imap-urlauth-login-settings.c */
 
3083
/* <settings checks> */
 
3084
static struct file_listener_settings
 
3085
imap_urlauth_login_unix_listeners_array[] = {
 
3086
        { "imap-urlauth", 0666, "", "" }
 
3087
};
 
3088
static struct file_listener_settings *imap_urlauth_login_unix_listeners[] = {
 
3089
        &imap_urlauth_login_unix_listeners_array[0]
 
3090
};
 
3091
static buffer_t imap_urlauth_login_unix_listeners_buf = {
 
3092
        imap_urlauth_login_unix_listeners,
 
3093
                sizeof(imap_urlauth_login_unix_listeners), { 0, }
 
3094
};
 
3095
/* </settings checks> */
 
3096
struct service_settings imap_urlauth_login_service_settings = {
 
3097
        .name = "imap-urlauth-login",
 
3098
        .protocol = "imap",
 
3099
        .type = "login",
 
3100
        .executable = "imap-urlauth-login",
 
3101
        .user = "$default_login_user",
 
3102
        .group = "",
 
3103
        .privileged_group = "",
 
3104
        .extra_groups = "",
 
3105
        .chroot = "token-login",
 
3106
 
 
3107
        .drop_priv_before_exec = FALSE,
 
3108
 
 
3109
        .process_min_avail = 0,
 
3110
        .process_limit = 0,
 
3111
        .client_limit = 0,
 
3112
        .service_count = 1,
 
3113
        .idle_kill = 0,
 
3114
        .vsz_limit = (uoff_t)-1,
 
3115
 
 
3116
        .unix_listeners = { { &imap_urlauth_login_unix_listeners_buf,
 
3117
                              sizeof(imap_urlauth_login_unix_listeners[0]) } },
 
3118
        .fifo_listeners = ARRAY_INIT,
 
3119
        .inet_listeners = ARRAY_INIT
 
3120
};
 
3121
static const struct setting_define imap_urlauth_login_setting_defines[] = {
 
3122
        SETTING_DEFINE_LIST_END
 
3123
};
 
3124
static const struct setting_parser_info *imap_urlauth_login_setting_dependencies[] = {
 
3125
        &login_setting_parser_info,
 
3126
        NULL
 
3127
};
 
3128
const struct setting_parser_info imap_urlauth_login_setting_parser_info = {
 
3129
        .module_name = "imap-urlauth-login",
 
3130
        .defines = imap_urlauth_login_setting_defines,
 
3131
 
 
3132
        .type_offset = (size_t)-1,
 
3133
        .parent_offset = (size_t)-1,
 
3134
 
 
3135
        .dependencies = imap_urlauth_login_setting_dependencies
 
3136
};
 
3137
const struct setting_parser_info *imap_urlauth_login_setting_roots[] = {
 
3138
        &login_setting_parser_info,
 
3139
        &imap_urlauth_login_setting_parser_info,
 
3140
        NULL
 
3141
};
2944
3142
/* ../../src/imap-login/imap-login-settings.c */
2945
3143
/* <settings checks> */
2946
3144
static struct inet_listener_settings imap_login_inet_listeners_array[] = {
2947
 
        { "imap", "", 143, FALSE },
2948
 
        { "imaps", "", 993, TRUE }
 
3145
        { .name = "imap", .address = "", .port = 143 },
 
3146
        { .name = "imaps", .address = "", .port = 993, .ssl = TRUE }
2949
3147
};
2950
3148
static struct inet_listener_settings *imap_login_inet_listeners[] = {
2951
3149
        &imap_login_inet_listeners_array[0],
2992
3190
};
2993
3191
static const struct imap_login_settings imap_login_default_settings = {
2994
3192
        .imap_capability = "",
2995
 
        .imap_id_send = "",
 
3193
        .imap_id_send = "name *",
2996
3194
        .imap_id_log = ""
2997
3195
};
2998
3196
static const struct setting_parser_info *imap_login_setting_dependencies[] = {
3028
3226
};
3029
3227
/* </settings checks> */
3030
3228
/* <settings checks> */
3031
 
static bool doveadm_settings_check(void *_set ATTR_UNUSED,
3032
 
                                   pool_t pool ATTR_UNUSED,
3033
 
                                   const char **error_r ATTR_UNUSED)
 
3229
static bool doveadm_settings_check(void *_set, pool_t pool ATTR_UNUSED,
 
3230
                                   const char **error_r)
3034
3231
{
3035
 
#ifndef CONFIG_BINARY
3036
3232
        struct doveadm_settings *set = _set;
3037
3233
 
 
3234
#ifndef CONFIG_BINARY
 
3235
        fix_base_path(set, pool, &set->auth_socket_path);
3038
3236
        fix_base_path(set, pool, &set->doveadm_socket_path);
3039
3237
#endif
 
3238
        if (*set->dsync_alt_char == '\0') {
 
3239
                *error_r = "dsync_alt_char must not be empty";
 
3240
                return FALSE;
 
3241
        }
3040
3242
        return TRUE;
3041
3243
}
3042
3244
/* </settings checks> */
3070
3272
        { type, #name, offsetof(struct doveadm_settings, name), NULL }
3071
3273
static const struct setting_define doveadm_setting_defines[] = {
3072
3274
        DEF(SET_STR, base_dir),
 
3275
        DEF(SET_STR, libexec_dir),
3073
3276
        DEF(SET_STR, mail_plugins),
3074
3277
        DEF(SET_STR, mail_plugin_dir),
 
3278
        DEF(SET_STR, auth_socket_path),
3075
3279
        DEF(SET_STR, doveadm_socket_path),
3076
3280
        DEF(SET_UINT, doveadm_worker_count),
3077
 
        DEF(SET_UINT, doveadm_proxy_port),
 
3281
        DEF(SET_UINT, doveadm_port),
 
3282
        { SET_ALIAS, "doveadm_proxy_port", 0, NULL },
3078
3283
        DEF(SET_STR, doveadm_password),
3079
3284
        DEF(SET_STR, doveadm_allowed_commands),
3080
3285
        DEF(SET_STR, dsync_alt_char),
3081
3286
        DEF(SET_STR, dsync_remote_cmd),
 
3287
        DEF(SET_STR, ssl_client_ca_dir),
 
3288
        DEF(SET_STR, ssl_client_ca_file),
3082
3289
 
3083
3290
        { SET_STRLIST, "plugin", offsetof(struct doveadm_settings, plugin_envs), NULL },
3084
3291
 
3086
3293
};
3087
3294
const struct doveadm_settings doveadm_default_settings = {
3088
3295
        .base_dir = PKG_RUNDIR,
 
3296
        .libexec_dir = PKG_LIBEXECDIR,
3089
3297
        .mail_plugins = "",
3090
3298
        .mail_plugin_dir = MODULEDIR,
 
3299
        .auth_socket_path = "auth-userdb",
3091
3300
        .doveadm_socket_path = "doveadm-server",
3092
3301
        .doveadm_worker_count = 0,
3093
 
        .doveadm_proxy_port = 0,
 
3302
        .doveadm_port = 0,
3094
3303
        .doveadm_password = "",
3095
3304
        .doveadm_allowed_commands = "",
3096
3305
        .dsync_alt_char = "_",
3097
 
        .dsync_remote_cmd = "ssh -l%{login} %{host} doveadm dsync-server -u%u -l%{lock_timeout} -n%{namespace}",
 
3306
        .dsync_remote_cmd = "ssh -l%{login} %{host} doveadm dsync-server -u%u -U",
 
3307
        .ssl_client_ca_dir = "",
 
3308
        .ssl_client_ca_file = "",
3098
3309
 
3099
3310
        .plugin_envs = ARRAY_INIT
3100
3311
};
3117
3328
/* ../../src/dns/dns-client-settings.c */
3118
3329
/* <settings checks> */
3119
3330
static struct file_listener_settings dns_client_unix_listeners_array[] = {
3120
 
        { "dns-client", 0666, "", "" },
3121
 
        { "login/dns-client", 0666, "", "" }
 
3331
        { "dns-client", 0666, "", "" }
3122
3332
};
3123
3333
static struct file_listener_settings *dns_client_unix_listeners[] = {
3124
 
        &dns_client_unix_listeners_array[0],
3125
 
        &dns_client_unix_listeners_array[1]
 
3334
        &dns_client_unix_listeners_array[0]
3126
3335
};
3127
3336
static buffer_t dns_client_unix_listeners_buf = {
3128
3337
        dns_client_unix_listeners, sizeof(dns_client_unix_listeners), { 0, }
3155
3364
};
3156
3365
/* ../../src/director/director-settings.c */
3157
3366
/* <settings checks> */
 
3367
static bool director_settings_verify(void *_set, pool_t pool, const char **error_r);
 
3368
 
3158
3369
static struct file_listener_settings director_unix_listeners_array[] = {
3159
3370
        { "login/director", 0, "", "" },
3160
3371
        { "director-admin", 0600, "", "" }
3178
3389
        sizeof(director_fifo_listeners), { 0, }
3179
3390
};
3180
3391
/* </settings checks> */
 
3392
/* <settings checks> */
 
3393
static bool
 
3394
director_settings_verify(void *_set, pool_t pool ATTR_UNUSED, const char **error_r)
 
3395
{
 
3396
        struct director_settings *set = _set;
 
3397
 
 
3398
        if (set->director_user_expire < 10) {
 
3399
                *error_r = "director_user_expire is too low";
 
3400
                return FALSE;
 
3401
        }
 
3402
        return TRUE;
 
3403
}
 
3404
/* </settings checks> */
3181
3405
struct service_settings director_service_settings = {
3182
3406
        .name = "director",
3183
3407
        .protocol = "",
3195
3419
        .process_limit = 1,
3196
3420
        .client_limit = 0,
3197
3421
        .service_count = 0,
3198
 
        .idle_kill = -1U,
 
3422
        .idle_kill = UINT_MAX,
3199
3423
        .vsz_limit = (uoff_t)-1,
3200
3424
 
3201
3425
        .unix_listeners = { { &director_unix_listeners_buf,
3225
3449
 
3226
3450
        .director_servers = "",
3227
3451
        .director_mail_servers = "",
3228
 
        .director_username_hash = "%u",
 
3452
        .director_username_hash = "%Lu",
3229
3453
        .director_user_expire = 60*15,
3230
3454
        .director_doveadm_port = 0
3231
3455
};
3237
3461
        .type_offset = (size_t)-1,
3238
3462
        .struct_size = sizeof(struct director_settings),
3239
3463
 
3240
 
        .parent_offset = (size_t)-1
 
3464
        .parent_offset = (size_t)-1,
 
3465
 
 
3466
        .check_func = director_settings_verify
3241
3467
};
3242
3468
/* ../../src/dict/dict-settings.c */
3243
3469
/* <settings checks> */
3344
3570
/* <settings checks> */
3345
3571
static struct file_listener_settings auth_unix_listeners_array[] = {
3346
3572
        { "login/login", 0666, "", "" },
 
3573
        { "token-login/tokenlogin", 0666, "", "" },
3347
3574
        { "auth-login", 0600, "$default_internal_user", "" },
3348
 
        { "auth-client", 0600, "", "" },
 
3575
        { "auth-client", 0600, "$default_internal_user", "" },
3349
3576
        { "auth-userdb", 0666, "$default_internal_user", "" },
3350
3577
        { "auth-master", 0600, "", "" }
3351
3578
};
3354
3581
        &auth_unix_listeners_array[1],
3355
3582
        &auth_unix_listeners_array[2],
3356
3583
        &auth_unix_listeners_array[3],
3357
 
        &auth_unix_listeners_array[4]
 
3584
        &auth_unix_listeners_array[4],
 
3585
        &auth_unix_listeners_array[5]
3358
3586
};
3359
3587
static buffer_t auth_unix_listeners_buf = {
3360
3588
        auth_unix_listeners, sizeof(auth_unix_listeners), { 0, }
3377
3605
                           const char **error_r)
3378
3606
{
3379
3607
        const char *const *tmp;
3380
 
        ARRAY_DEFINE(ips_array, struct ip_addr);
 
3608
        ARRAY(struct ip_addr) ips_array;
3381
3609
        struct ip_addr *ips;
3382
3610
        unsigned int ips_count;
3383
3611
        int ret;
3398
3626
                }
3399
3627
                array_append(&ips_array, ips, ips_count);
3400
3628
        }
3401
 
        (void)array_append_space(&ips_array);
 
3629
        array_append_zero(&ips_array);
3402
3630
        set->proxy_self_ips = array_idx(&ips_array, 0);
3403
3631
        return TRUE;
3404
3632
}
3405
3633
 
 
3634
static bool
 
3635
auth_verify_verbose_password(const struct auth_settings *set,
 
3636
                             const char **error_r)
 
3637
{
 
3638
        const char *p, *value = set->verbose_passwords;
 
3639
        unsigned int num;
 
3640
 
 
3641
        p = strchr(value, ':');
 
3642
        if (p != NULL) {
 
3643
                if (str_to_uint(p+1, &num) < 0 || num == 0) {
 
3644
                        *error_r = t_strdup_printf("auth_verbose_passwords: "
 
3645
                                "Invalid truncation number: '%s'", p+1);
 
3646
                        return FALSE;
 
3647
                }
 
3648
                value = t_strdup_until(value, p);
 
3649
        }
 
3650
        if (strcmp(value, "no") == 0)
 
3651
                return TRUE;
 
3652
        else if (strcmp(value, "plain") == 0)
 
3653
                return TRUE;
 
3654
        else if (strcmp(value, "sha1") == 0)
 
3655
                return TRUE;
 
3656
        else
 
3657
                return FALSE;
 
3658
}
 
3659
 
3406
3660
static bool auth_settings_check(void *_set, pool_t pool,
3407
3661
                                const char **error_r)
3408
3662
{
3428
3682
                return FALSE;
3429
3683
        }
3430
3684
 
 
3685
        if (!auth_verify_verbose_password(set, error_r))
 
3686
                return FALSE;
 
3687
 
3431
3688
        if (*set->username_chars == '\0') {
3432
3689
                /* all chars are allowed */
3433
3690
                memset(set->username_chars_map, 1,
3460
3717
                *error_r = "passdb is missing driver";
3461
3718
                return FALSE;
3462
3719
        }
 
3720
        if (set->pass && strcmp(set->result_success, "return-ok") != 0) {
 
3721
                *error_r = "Obsolete pass=yes setting mixed with non-default result_success";
 
3722
                return FALSE;
 
3723
        }
3463
3724
        return TRUE;
3464
3725
}
3465
3726
 
3536
3797
        DEF(SET_STR, args),
3537
3798
        DEF(SET_STR, default_fields),
3538
3799
        DEF(SET_STR, override_fields),
 
3800
        DEF(SET_ENUM, skip),
 
3801
        DEF(SET_ENUM, result_success),
 
3802
        DEF(SET_ENUM, result_failure),
 
3803
        DEF(SET_ENUM, result_internalfail),
3539
3804
        DEF(SET_BOOL, deny),
3540
3805
        DEF(SET_BOOL, pass),
3541
3806
        DEF(SET_BOOL, master),
3547
3812
        .args = "",
3548
3813
        .default_fields = "",
3549
3814
        .override_fields = "",
 
3815
        .skip = "never:authenticated:unauthenticated",
 
3816
        .result_success = "return-ok:return:return-fail:continue:continue-ok:continue-fail",
 
3817
        .result_failure = "continue:return:return-ok:return-fail:continue-ok:continue-fail",
 
3818
        .result_internalfail = "continue:return:return-ok:return-fail:continue-ok:continue-fail",
3550
3819
        .deny = FALSE,
3551
3820
        .pass = FALSE,
3552
3821
        .master = FALSE
3618
3887
        DEF(SET_STR, winbind_helper_path),
3619
3888
        DEF(SET_STR, proxy_self),
3620
3889
        DEF(SET_TIME, failure_delay),
3621
 
        DEF(SET_UINT, first_valid_uid),
3622
 
        DEF(SET_UINT, last_valid_uid),
3623
3890
 
3624
3891
        DEF(SET_BOOL, verbose),
3625
3892
        DEF(SET_BOOL, debug),
3626
3893
        DEF(SET_BOOL, debug_passwords),
3627
 
        DEF(SET_ENUM, verbose_passwords),
 
3894
        DEF(SET_STR, verbose_passwords),
3628
3895
        DEF(SET_BOOL, ssl_require_client_cert),
3629
3896
        DEF(SET_BOOL, ssl_username_from_cert),
3630
3897
        DEF(SET_BOOL, use_winbind),
3636
3903
 
3637
3904
        DEF_NOPREFIX(SET_STR, base_dir),
3638
3905
        DEF_NOPREFIX(SET_BOOL, verbose_proctitle),
 
3906
        DEF_NOPREFIX(SET_UINT, first_valid_uid),
 
3907
        DEF_NOPREFIX(SET_UINT, last_valid_uid),
3639
3908
 
3640
3909
        SETTING_DEFINE_LIST_END
3641
3910
};
3656
3925
        .winbind_helper_path = "/usr/bin/ntlm_auth",
3657
3926
        .proxy_self = "",
3658
3927
        .failure_delay = 2,
3659
 
        .first_valid_uid = 500,
3660
 
        .last_valid_uid = 0,
3661
3928
 
3662
3929
        .verbose = FALSE,
3663
3930
        .debug = FALSE,
3664
3931
        .debug_passwords = FALSE,
3665
 
        .verbose_passwords = "no:plain:sha1",
 
3932
        .verbose_passwords = "no",
3666
3933
        .ssl_require_client_cert = FALSE,
3667
3934
        .ssl_username_from_cert = FALSE,
3668
3935
        .use_winbind = FALSE,
3673
3940
        .userdbs = ARRAY_INIT,
3674
3941
 
3675
3942
        .base_dir = PKG_RUNDIR,
3676
 
        .verbose_proctitle = FALSE
 
3943
        .verbose_proctitle = FALSE,
 
3944
        .first_valid_uid = 500,
 
3945
        .last_valid_uid = 0,
3677
3946
};
3678
3947
const struct setting_parser_info auth_setting_parser_info = {
3679
3948
        .module_name = "auth",
3718
3987
        .process_limit = 1,
3719
3988
        .client_limit = 0,
3720
3989
        .service_count = 0,
3721
 
        .idle_kill = -1U,
 
3990
        .idle_kill = UINT_MAX,
3722
3991
        .vsz_limit = (uoff_t)-1,
3723
3992
 
3724
3993
        .unix_listeners = { { &anvil_unix_listeners_buf,
3744
4013
        &indexer_worker_service_settings,
3745
4014
        &indexer_service_settings,
3746
4015
        &imap_service_settings,
 
4016
        &imap_urlauth_worker_service_settings,
 
4017
        &imap_urlauth_service_settings,
 
4018
        &imap_urlauth_login_service_settings,
3747
4019
        &imap_login_service_settings,
3748
4020
        &doveadm_service_settings,
3749
4021
        &dns_client_service_settings,
3758
4030
        config_all_services, sizeof(config_all_services), { 0, }
3759
4031
};
3760
4032
const struct setting_parser_info *all_default_roots[] = {
3761
 
        &dict_setting_parser_info, 
3762
 
        &master_setting_parser_info, 
 
4033
        &master_service_setting_parser_info,
 
4034
        &master_service_ssl_setting_parser_info,
 
4035
        &stats_setting_parser_info, 
 
4036
        &lda_setting_parser_info, 
 
4037
        &imap_urlauth_setting_parser_info, 
 
4038
        &imap_urlauth_login_setting_parser_info, 
 
4039
        &pop3c_setting_parser_info, 
 
4040
        &auth_setting_parser_info, 
3763
4041
        &pop3_login_setting_parser_info, 
3764
 
        &pop3_setting_parser_info, 
 
4042
        &mbox_setting_parser_info, 
 
4043
        &lmtp_setting_parser_info, 
 
4044
        &director_setting_parser_info, 
3765
4045
        &replicator_setting_parser_info, 
3766
 
        &lda_setting_parser_info, 
3767
 
        &aggregator_setting_parser_info, 
3768
 
        &ssl_params_setting_parser_info, 
 
4046
        &mail_user_setting_parser_info, 
3769
4047
        &mdbox_setting_parser_info, 
3770
4048
        &doveadm_setting_parser_info, 
3771
 
        &mail_user_setting_parser_info, 
 
4049
        &master_setting_parser_info, 
 
4050
        &aggregator_setting_parser_info, 
 
4051
        &login_setting_parser_info, 
 
4052
        &mail_storage_setting_parser_info, 
3772
4053
        &imap_login_setting_parser_info, 
3773
 
        &mail_storage_setting_parser_info, 
3774
 
        &director_setting_parser_info, 
3775
 
        &stats_setting_parser_info, 
 
4054
        &ssl_params_setting_parser_info, 
3776
4055
        &imapc_setting_parser_info, 
 
4056
        &imap_setting_parser_info, 
 
4057
        &pop3_setting_parser_info, 
 
4058
        &dict_setting_parser_info, 
3777
4059
        &maildir_setting_parser_info, 
3778
 
        &lmtp_setting_parser_info, 
3779
 
        &master_service_setting_parser_info, 
3780
 
        &login_setting_parser_info, 
3781
 
        &auth_setting_parser_info, 
3782
 
        &mbox_setting_parser_info, 
3783
 
        &pop3c_setting_parser_info, 
3784
 
        &imap_setting_parser_info, 
 
4060
        &imap_urlauth_worker_setting_parser_info, 
3785
4061
        NULL
3786
4062
};
3787
4063
const struct setting_parser_info *const *all_roots = all_default_roots;