/*- * Copyright 2016 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "config.h" #include "contrib/libev/ev.h" #include "redis_pool.h" #include "cfg_file.h" #include "contrib/hiredis/hiredis.h" #include "contrib/hiredis/async.h" #include "contrib/hiredis/adapters/libev.h" #include "cryptobox.h" #include "logger.h" #include #include "contrib/robin-hood/robin_hood.h" #include "libutil/cxx/local_shared_ptr.hxx" namespace rspamd { class redis_pool_elt; class redis_pool; #define msg_err_rpool(...) rspamd_default_log_function (G_LOG_LEVEL_CRITICAL, \ "redis_pool", conn->tag, \ __FUNCTION__, \ __VA_ARGS__) #define msg_warn_rpool(...) rspamd_default_log_function (G_LOG_LEVEL_WARNING, \ "redis_pool", conn->tag, \ __FUNCTION__, \ __VA_ARGS__) #define msg_info_rpool(...) rspamd_default_log_function (G_LOG_LEVEL_INFO, \ "redis_pool", conn->tag, \ __FUNCTION__, \ __VA_ARGS__) #define msg_debug_rpool(...) rspamd_conditional_debug_fast (NULL, NULL, \ rspamd_redis_pool_log_id, "redis_pool", conn->tag, \ __FUNCTION__, \ __VA_ARGS__) INIT_LOG_MODULE(redis_pool) enum rspamd_redis_pool_connection_state { RSPAMD_REDIS_POOL_CONN_INACTIVE = 0, RSPAMD_REDIS_POOL_CONN_ACTIVE, RSPAMD_REDIS_POOL_CONN_FINALISING }; struct redis_pool_connection { using redis_pool_connection_ptr = std::unique_ptr; using conn_iter_t = std::list::iterator; struct redisAsyncContext *ctx; redis_pool_elt *elt; redis_pool *pool; conn_iter_t elt_pos; ev_timer timeout; enum rspamd_redis_pool_connection_state state; gchar tag[MEMPOOL_UID_LEN]; auto schedule_timeout() -> void; ~redis_pool_connection(); explicit redis_pool_connection(redis_pool *_pool, redis_pool_elt *_elt, const std::string &db, const std::string &password, struct redisAsyncContext *_ctx); private: static auto redis_conn_timeout_cb(EV_P_ ev_timer *w, int revents) -> void; static auto redis_quit_cb(redisAsyncContext *c, void *r, void *priv) -> void; static auto redis_on_disconnect(const struct redisAsyncContext *ac, int status) -> auto; }; using redis_pool_key_t = std::uint64_t; class redis_pool; class redis_pool_elt { using redis_pool_connection_ptr = std::unique_ptr; redis_pool *pool; /* * These lists owns connections, so if an element is removed from both * lists, it is destructed */ std::list active; std::list inactive; std::list terminating; std::string ip; std::string db; std::string password; int port; redis_pool_key_t key; bool is_unix; public: explicit redis_pool_elt(redis_pool *_pool, const gchar *_db, const gchar *_password, const char *_ip, int _port) : pool(_pool), ip(_ip), port(_port), key(redis_pool_elt::make_key(_db, _password, _ip, _port)) { is_unix = ip[0] == '.' || ip[0] == '/'; if (_db) { db = _db; } if (_password) { password = _password; } } auto new_connection() -> redisAsyncContext *; auto release_connection(const redis_pool_connection *conn) -> void { switch(conn->state) { case RSPAMD_REDIS_POOL_CONN_ACTIVE: active.erase(conn->elt_pos); break; case RSPAMD_REDIS_POOL_CONN_INACTIVE: inactive.erase(conn->elt_pos); break; case RSPAMD_REDIS_POOL_CONN_FINALISING: terminating.erase(conn->elt_pos); break; } } auto move_to_inactive(redis_pool_connection *conn) -> void { inactive.splice(std::end(inactive), active, conn->elt_pos); conn->elt_pos = std::prev(std::end(inactive)); } auto move_to_terminating(redis_pool_connection *conn) -> void { terminating.splice(std::end(terminating), terminating, conn->elt_pos); conn->elt_pos = std::prev(std::end(terminating)); } inline static auto make_key(const gchar *db, const gchar *password, const char *ip, int port) -> redis_pool_key_t { rspamd_cryptobox_fast_hash_state_t st; rspamd_cryptobox_fast_hash_init(&st, rspamd_hash_seed()); if (db) { rspamd_cryptobox_fast_hash_update(&st, db, strlen(db)); } if (password) { rspamd_cryptobox_fast_hash_update(&st, password, strlen(password)); } rspamd_cryptobox_fast_hash_update(&st, ip, strlen(ip)); rspamd_cryptobox_fast_hash_update(&st, &port, sizeof(port)); return rspamd_cryptobox_fast_hash_final(&st); } auto num_active() const -> auto { return active.size(); } ~redis_pool_elt() { rspamd_explicit_memzero(password.data(), password.size()); } private: auto redis_async_new() -> redisAsyncContext * { struct redisAsyncContext *ctx; if (is_unix) { ctx = redisAsyncConnectUnix(ip.c_str()); } else { ctx = redisAsyncConnect(ip.c_str(), port); } if (ctx && ctx->err != REDIS_OK) { msg_err("cannot connect to redis %s (port %d): %s", ip.c_str(), port, ctx->errstr); redisAsyncFree(ctx); return nullptr; } return ctx; } }; class redis_pool final { static constexpr const double default_timeout = 10.0; static constexpr const unsigned default_max_conns = 100; /* We want to have references integrity */ robin_hood::unordered_flat_map conns_by_ctx; robin_hood::unordered_node_map elts_by_key; bool wanna_die = false; /* Hiredis is 'clever' so we can call ourselves from destructor */ public: double timeout = default_timeout; unsigned max_conns = default_max_conns; struct ev_loop *event_loop; struct rspamd_config *cfg; public: explicit redis_pool() : event_loop(nullptr), cfg(nullptr) { conns_by_ctx.reserve(max_conns); } /* Legacy stuff */ auto do_config(struct ev_loop *_loop, struct rspamd_config *_cfg) -> void { event_loop = _loop; cfg = _cfg; } auto new_connection(const gchar *db, const gchar *password, const char *ip, int port) -> redisAsyncContext *; auto release_connection(redisAsyncContext *ctx, enum rspamd_redis_pool_release_type how) -> void; auto unregister_context(redisAsyncContext *ctx) -> void { conns_by_ctx.erase(ctx); } auto register_context(redisAsyncContext *ctx, redis_pool_connection *conn) { conns_by_ctx.emplace(ctx, conn); } ~redis_pool() { /* * XXX: this will prevent hiredis to unregister connections that * are already destroyed during redisAsyncFree... */ wanna_die = true; } }; redis_pool_connection::~redis_pool_connection() { const auto *conn = this; /* For debug */ if (state == RSPAMD_REDIS_POOL_CONN_ACTIVE) { msg_debug_rpool ("active connection destructed"); if (ctx) { if (!(ctx->c.flags & REDIS_FREEING)) { auto *ac = ctx; ctx = nullptr; pool->unregister_context(ac); ac->onDisconnect = nullptr; redisAsyncFree(ac); } } } else { msg_debug_rpool("inactive connection destructed"); ev_timer_stop(pool->event_loop, &timeout); if (ctx && !(ctx->c.flags & REDIS_FREEING)) { redisAsyncContext *ac = ctx; /* To prevent on_disconnect here */ state = RSPAMD_REDIS_POOL_CONN_FINALISING; pool->unregister_context(ac); ctx = nullptr; ac->onDisconnect = nullptr; redisAsyncFree(ac); } } } auto redis_pool_connection::redis_quit_cb(redisAsyncContext *c, void *r, void *priv) -> void { struct redis_pool_connection *conn = (struct redis_pool_connection *) priv; msg_debug_rpool("quit command reply for the connection %p", conn->ctx); /* * The connection will be freed by hiredis itself as we are here merely after * quit command has succeeded and we have timer being set already. * The problem is that when this callback is called, our connection is likely * dead, so probably even on_disconnect callback has been already called... * * Hence, the connection might already be freed, so even (conn) pointer may be * inaccessible. * * TODO: Use refcounts to prevent this stuff to happen, the problem is how * to handle Redis timeout on `quit` command in fact... The good thing is that * it will not likely happen. */ } /* * Called for inactive connections that due to be removed */ auto redis_pool_connection::redis_conn_timeout_cb(EV_P_ ev_timer *w, int revents) -> void { auto *conn = (struct redis_pool_connection *) w->data; g_assert (conn->state != RSPAMD_REDIS_POOL_CONN_ACTIVE); if (conn->state == RSPAMD_REDIS_POOL_CONN_INACTIVE) { msg_debug_rpool("scheduled soft removal of connection %p", conn->ctx); conn->state = RSPAMD_REDIS_POOL_CONN_FINALISING; ev_timer_again(EV_A_ w); redisAsyncCommand(conn->ctx, redis_pool_connection::redis_quit_cb, conn, "QUIT"); conn->elt->move_to_terminating(conn); } else { /* Finalising by timeout */ ev_timer_stop(EV_A_ w); msg_debug_rpool("final removal of connection %p, refcount: %d", conn->ctx); /* Erasure of shared pointer will cause it to be removed */ conn->elt->release_connection(conn); } } auto redis_pool_connection::redis_on_disconnect(const struct redisAsyncContext *ac, int status) -> auto { auto *conn = (struct redis_pool_connection *) ac->data; /* * Here, we know that redis itself will free this connection * so, we need to do something very clever about it */ if (conn->state != RSPAMD_REDIS_POOL_CONN_ACTIVE) { /* Do nothing for active connections as it is already handled somewhere */ if (conn->ctx) { msg_debug_rpool("inactive connection terminated: %s", conn->ctx->errstr); } /* Erasure of shared pointer will cause it to be removed */ conn->elt->release_connection(conn); } } auto redis_pool_connection::schedule_timeout() -> void { const auto *conn = this; /* For debug */ double real_timeout; auto active_elts = elt->num_active(); if (active_elts > pool->max_conns) { real_timeout = pool->timeout / 2.0; real_timeout = rspamd_time_jitter(real_timeout, real_timeout / 4.0); } else { real_timeout = pool->timeout; real_timeout = rspamd_time_jitter(real_timeout, real_timeout / 2.0); } msg_debug_rpool("scheduled connection %p cleanup in %.1f seconds", ctx, real_timeout); timeout.data = this; ev_timer_init(&timeout, redis_pool_connection::redis_conn_timeout_cb, real_timeout, real_timeout / 2.0); ev_timer_start(pool->event_loop, &timeout); } redis_pool_connection::redis_pool_connection(redis_pool *_pool, redis_pool_elt *_elt, const std::string &db, const std::string &password, struct redisAsyncContext *_ctx) : ctx(_ctx), elt(_elt), pool(_pool) { state = RSPAMD_REDIS_POOL_CONN_ACTIVE; pool->register_context(ctx, this); ctx->data = this; memset(tag, 0, sizeof(tag)); rspamd_random_hex((guchar *)tag, sizeof(tag) - 1); redisLibevAttach(pool->event_loop, ctx); redisAsyncSetDisconnectCallback(ctx, redis_pool_connection::redis_on_disconnect); if (!password.empty()) { redisAsyncCommand(ctx, nullptr, nullptr, "AUTH %s", password.c_str()); } if (!db.empty()) { redisAsyncCommand(ctx, nullptr, nullptr, "SELECT %s", db.c_str()); } } auto redis_pool_elt::new_connection() -> redisAsyncContext * { if (!inactive.empty()) { decltype(inactive)::value_type conn; conn.swap(inactive.back()); inactive.pop_back(); g_assert (conn->state != RSPAMD_REDIS_POOL_CONN_ACTIVE); if (conn->ctx->err == REDIS_OK) { /* Also check SO_ERROR */ gint err; socklen_t len = sizeof(gint); if (getsockopt(conn->ctx->c.fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len) == -1) { err = errno; } if (err != 0) { /* * We cannot reuse connection, so we just recursively call * this function one more time */ return new_connection(); } else { /* Reuse connection */ ev_timer_stop(pool->event_loop, &conn->timeout); conn->state = RSPAMD_REDIS_POOL_CONN_ACTIVE; msg_debug_rpool("reused existing connection to %s:%d: %p", ip.c_str(), port, conn->ctx); active.emplace_front(std::move(conn)); active.front()->elt_pos = active.begin(); return active.front()->ctx; } } else { auto *nctx = redis_async_new(); if (nctx) { active.emplace_front(std::make_unique(pool, this, db.c_str(), password.c_str(), nctx)); active.front()->elt_pos = active.begin(); } return nctx; } } else { auto *nctx = redis_async_new(); if (nctx) { active.emplace_front(std::make_unique(pool, this, db.c_str(), password.c_str(), nctx)); active.front()->elt_pos = active.begin(); } return nctx; } RSPAMD_UNREACHABLE; } auto redis_pool::new_connection(const gchar *db, const gchar *password, const char *ip, int port) -> redisAsyncContext * { if (!wanna_die) { auto key = redis_pool_elt::make_key(db, password, ip, port); auto found_elt = elts_by_key.find(key); if (found_elt != elts_by_key.end()) { auto &elt = found_elt->second; return elt.new_connection(); } else { /* Need to create a pool */ auto nelt = elts_by_key.emplace(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(this, db, password, ip, port)); return nelt.first->second.new_connection(); } } return nullptr; } auto redis_pool::release_connection(redisAsyncContext *ctx, enum rspamd_redis_pool_release_type how) -> void { if (!wanna_die) { auto conn_it = conns_by_ctx.find(ctx); if (conn_it != conns_by_ctx.end()) { auto *conn = conn_it->second; g_assert (conn->state == RSPAMD_REDIS_POOL_CONN_ACTIVE); if (ctx->err != REDIS_OK) { /* We need to terminate connection forcefully */ msg_debug_rpool ("closed connection %p due to an error", conn->ctx); } else { if (how == RSPAMD_REDIS_RELEASE_DEFAULT) { /* Ensure that there are no callbacks attached to this conn */ if (ctx->replies.head == nullptr) { /* Just move it to the inactive queue */ conn->state = RSPAMD_REDIS_POOL_CONN_INACTIVE; conn->elt->move_to_inactive(conn); conn->schedule_timeout(); msg_debug_rpool("mark connection %p inactive", conn->ctx); return; } else { msg_debug_rpool("closed connection %p due to callbacks left", conn->ctx); } } else { if (how == RSPAMD_REDIS_RELEASE_FATAL) { msg_debug_rpool("closed connection %p due to an fatal termination", conn->ctx); } else { msg_debug_rpool("closed connection %p due to explicit termination", conn->ctx); } } } conn->elt->release_connection(conn); } else { RSPAMD_UNREACHABLE; } } } } void * rspamd_redis_pool_init(void) { return new rspamd::redis_pool{}; } void rspamd_redis_pool_config(void *p, struct rspamd_config *cfg, struct ev_loop *ev_base) { g_assert (p != NULL); auto *pool = reinterpret_cast(p); pool->do_config(ev_base, cfg); } struct redisAsyncContext * rspamd_redis_pool_connect(void *p, const gchar *db, const gchar *password, const char *ip, int port) { g_assert (p != NULL); auto *pool = reinterpret_cast(p); return pool->new_connection(db, password, ip, port); } void rspamd_redis_pool_release_connection(void *p, struct redisAsyncContext *ctx, enum rspamd_redis_pool_release_type how) { g_assert (p != NULL); g_assert (ctx != NULL); auto *pool = reinterpret_cast(p); pool->release_connection(ctx, how); } void rspamd_redis_pool_destroy(void *p) { auto *pool = reinterpret_cast(p); delete pool; } const gchar * rspamd_redis_type_to_string(int type) { const gchar *ret = "unknown"; switch (type) { case REDIS_REPLY_STRING: ret = "string"; break; case REDIS_REPLY_ARRAY: ret = "array"; break; case REDIS_REPLY_INTEGER: ret = "int"; break; case REDIS_REPLY_STATUS: ret = "status"; break; case REDIS_REPLY_NIL: ret = "nil"; break; case REDIS_REPLY_ERROR: ret = "error"; break; default: break; } return ret; } ort/47425/stable28'>backport/47425/stable28 Nextcloud server, a safe home for all your data: https://github.com/nextcloud/serverwww-data
summaryrefslogtreecommitdiffstats
path: root/l10n/uk/files_external.po
blob: 1cbdd57edac08fa911be5dedb20c698a13bf36f7 (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339

# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
# 
# Translators:
# Soul Kim <warlock.rf@gmail.com>, 2013
msgid ""
msgstr ""
"Project-Id-Version: ownCloud\n"
"Report-Msgid-Bugs-To: translations@owncloud.org\n"
"POT-Creation-Date: 2014-08-16 01:54-0400\n"
"PO-Revision-Date: 2014-08-16 05:03+0000\n"
"Last-Translator: I Robot\n"
"Language-Team: Ukrainian (http://www.transifex.com/projects/p/owncloud/language/uk/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: uk\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"

#: ajax/dropbox.php:27
msgid ""
"Fetching request tokens failed. Verify that your Dropbox app key and secret "
"are correct."
msgstr ""

#: ajax/dropbox.php:40
msgid ""
"Fetching access tokens failed. Verify that your Dropbox app key and secret "
"are correct."
msgstr ""

#: ajax/dropbox.php:48 js/dropbox.js:102
msgid "Please provide a valid Dropbox app key and secret."
msgstr "Будь ласка, надайте дійсний ключ та пароль Dropbox."

#: ajax/google.php:27
#, php-format
msgid "Step 1 failed. Exception: %s"
msgstr ""

#: ajax/google.php:38
#, php-format
msgid "Step 2 failed. Exception: %s"
msgstr ""

#: appinfo/app.php:35 js/app.js:32 templates/settings.php:9
msgid "External storage"
msgstr "Зовнішнє сховище"

#: appinfo/app.php:44
msgid "Local"
msgstr ""

#: appinfo/app.php:47
msgid "Location"
msgstr "Місце"

#: appinfo/app.php:50
msgid "Amazon S3"
msgstr ""

#: appinfo/app.php:53
msgid "Key"
msgstr ""

#: appinfo/app.php:54
msgid "Secret"
msgstr ""

#: appinfo/app.php:55 appinfo/app.php:64
msgid "Bucket"
msgstr ""

#: appinfo/app.php:59
msgid "Amazon S3 and compliant"
msgstr ""

#: appinfo/app.php:62
msgid "Access Key"
msgstr ""

#: appinfo/app.php:63
msgid "Secret Key"
msgstr ""

#: appinfo/app.php:65
msgid "Hostname (optional)"
msgstr ""

#: appinfo/app.php:66
msgid "Port (optional)"
msgstr ""

#: appinfo/app.php:67
msgid "Region (optional)"
msgstr ""

#: appinfo/app.php:68
msgid "Enable SSL"
msgstr ""

#: appinfo/app.php:69
msgid "Enable Path Style"
msgstr ""

#: appinfo/app.php:77
msgid "App key"
msgstr ""

#: appinfo/app.php:78
msgid "App secret"
msgstr ""

#: appinfo/app.php:88 appinfo/app.php:129 appinfo/app.php:140
#: appinfo/app.php:173
msgid "Host"
msgstr "Хост"

#: appinfo/app.php:89 appinfo/app.php:130 appinfo/app.php:152
#: appinfo/app.php:163 appinfo/app.php:174
msgid "Username"
msgstr "Ім'я користувача"

#: appinfo/app.php:90 appinfo/app.php:131 appinfo/app.php:153
#: appinfo/app.php:164 appinfo/app.php:175
msgid "Password"
msgstr "Пароль"

#: appinfo/app.php:91 appinfo/app.php:133 appinfo/app.php:143
#: appinfo/app.php:154 appinfo/app.php:176
msgid "Root"
msgstr ""

#: appinfo/app.php:92
msgid "Secure ftps://"
msgstr ""

#: appinfo/app.php:100
msgid "Client ID"
msgstr ""

#: appinfo/app.php:101
msgid "Client secret"
msgstr ""

#: appinfo/app.php:108
msgid "OpenStack Object Storage"
msgstr ""

#: appinfo/app.php:111
msgid "Username (required)"
msgstr ""

#: appinfo/app.php:112
msgid "Bucket (required)"
msgstr ""

#: appinfo/app.php:113
msgid "Region (optional for OpenStack Object Storage)"
msgstr ""

#: appinfo/app.php:114
msgid "API Key (required for Rackspace Cloud Files)"
msgstr ""

#: appinfo/app.php:115
msgid "Tenantname (required for OpenStack Object Storage)"
msgstr ""

#: appinfo/app.php:116
msgid "Password (required for OpenStack Object Storage)"
msgstr ""

#: appinfo/app.php:117
msgid "Service Name (required for OpenStack Object Storage)"
msgstr ""

#: appinfo/app.php:118
msgid "URL of identity endpoint (required for OpenStack Object Storage)"
msgstr ""

#: appinfo/app.php:119
msgid "Timeout of HTTP requests in seconds (optional)"
msgstr ""

#: appinfo/app.php:132 appinfo/app.php:142
msgid "Share"
msgstr "Поділитися"

#: appinfo/app.php:137
msgid "SMB / CIFS using OC login"
msgstr ""

#: appinfo/app.php:141
msgid "Username as share"
msgstr ""

#: appinfo/app.php:151 appinfo/app.php:162
msgid "URL"
msgstr "URL"

#: appinfo/app.php:155 appinfo/app.php:166
msgid "Secure https://"
msgstr ""

#: appinfo/app.php:165
msgid "Remote subfolder"
msgstr ""

#: js/dropbox.js:7 js/dropbox.js:29 js/google.js:8 js/google.js:40
msgid "Access granted"
msgstr "Доступ дозволено"

#: js/dropbox.js:33 js/dropbox.js:97 js/dropbox.js:103
msgid "Error configuring Dropbox storage"
msgstr "Помилка при налаштуванні сховища Dropbox"

#: js/dropbox.js:68 js/google.js:89
msgid "Grant access"
msgstr "Дозволити доступ"

#: js/google.js:45 js/google.js:122
msgid "Error configuring Google Drive storage"
msgstr "Помилка при налаштуванні сховища Google Drive"

#: js/mountsfilelist.js:34
msgid "Personal"
msgstr "Особисте"

#: js/mountsfilelist.js:36
msgid "System"
msgstr ""

#: js/settings.js:325 js/settings.js:332
msgid "Saved"
msgstr ""

#: lib/config.php:712
msgid "<b>Note:</b> "
msgstr ""

#: lib/config.php:722
msgid " and "
msgstr ""

#: lib/config.php:744
#, php-format
msgid ""
"<b>Note:</b> The cURL support in PHP is not enabled or installed. Mounting "
"of %s is not possible. Please ask your system administrator to install it."
msgstr ""

#: lib/config.php:746
#, php-format
msgid ""
"<b>Note:</b> The FTP support in PHP is not enabled or installed. Mounting of"
" %s is not possible. Please ask your system administrator to install it."
msgstr ""

#: lib/config.php:748
#, php-format
msgid ""
"<b>Note:</b> \"%s\" is not installed. Mounting of %s is not possible. Please"
" ask your system administrator to install it."
msgstr ""

#: templates/list.php:7
msgid "You don't have any external storages"
msgstr ""

#: templates/list.php:16
msgid "Name"
msgstr "Ім'я"

#: templates/list.php:20
msgid "Storage type"
msgstr ""

#: templates/list.php:23
msgid "Scope"
msgstr ""

#: templates/settings.php:2
msgid "External Storage"
msgstr "Зовнішні сховища"

#: templates/settings.php:8 templates/settings.php:27
msgid "Folder name"
msgstr "Ім'я теки"

#: templates/settings.php:10
msgid "Configuration"
msgstr "Налаштування"

#: templates/settings.php:11
msgid "Available for"
msgstr ""

#: templates/settings.php:33
msgid "Add storage"
msgstr "Додати сховище"

#: templates/settings.php:93
msgid "No user or group"
msgstr ""

#: templates/settings.php:96
msgid "All Users"
msgstr "Усі користувачі"

#: templates/settings.php:98
msgid "Groups"
msgstr "Групи"

#: templates/settings.php:106
msgid "Users"
msgstr "Користувачі"

#: templates/settings.php:119 templates/settings.php:120
#: templates/settings.php:159 templates/settings.php:160
msgid "Delete"
msgstr "Видалити"

#: templates/settings.php:133
msgid "Enable User External Storage"
msgstr "Активувати користувацькі зовнішні сховища"

#: templates/settings.php:136
msgid "Allow users to mount the following external storage"
msgstr ""

#: templates/settings.php:151
msgid "SSL root certificates"
msgstr "SSL корневі сертифікати"

#: templates/settings.php:169
msgid "Import Root Certificate"
msgstr "Імпортувати корневі сертифікати"
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-31 19:53:06 +0000