NNTPGrab

automation

base

client/gui

client/macosx

client/web/module

glue

gui_base

indexer

nntpgrab_core

plugins/decoder

plugins/jsonrpc

plugins/par2/par2cmdline

plugins/par2

plugins/unpack/file-roller/copy-n-paste

plugins/unpack/file-roller/nautilus

plugins/unpack/file-roller/src

plugins/unpack

server_qt

../deps/include

../deps/include/gio-unix-2.0

../deps/include/gio-unix-2.0/gio

../deps/include/glib-2.0

../deps/include/glib-2.0/gio

../deps/include/glib-2.0/glib

../deps/include/glib-2.0/gobject

../deps/include/libsoup-2.4

../deps/include/libsoup-2.4/libsoup

/usr/include

/usr/include/libxml2

/usr/include/glib-2.0

/usr/include/glib-2.0/glib

/usr/include/glib-2.0/gobject

/usr/include/glib-2.0/gthread

/usr/include/cairo

/usr/include/pango-1.0

/usr/include/pango-1.0/pango

/usr/include/gtk-2.0

/usr/include/gtk-2.0/gdk

/usr/include/gtk-2.0/gdk-pixbuf

/usr/include/gtk-2.0/gdk-pixbuf-xlib

/usr/include/libgtkhtml-3.14

/usr/include/libgtkhtml-3.14/editor

/usr/include/libgtkhtml-3.14/gtkhtml

/usr/include/libsoup-2.4

/usr/include/libsoup-gnome-2.4

/usr/include/libnm-glib

/usr/include/NetworkManager

/usr/include/gnutls

/usr/lib64/glib-2.0/include

/usr/include/QtSolutions/

/*

    Copyright (C) 2005-2010  Erik van Pienbroek

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#ifndef _DECODER_THREAD_H_

#define _DECODER_THREAD_H_

#include "collections.h"

#include "configuration.h"

typedef struct _decoder_data {

    NNTPCollection  *collection;

    NNTPFile        *file;

    //GThreadPool     *poolPar2verify;

    //GThreadPool     *poolPar2repair;

    //GThreadPool     *poolUnpack;

} DecoderData;

void         decoder_thread_initialize(Configuration *config);

void         decoder_thread_destroy(void);

gboolean     decoder_thread_start(void);

gboolean     decoder_thread_stop(void);

void         decoder_thread_push_task(DecoderData *task);

#endif /* _DECODER_THREAD_H_ */

/*

    Copyright (C) 2005-2011  Erik van Pienbroek

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#ifndef _NNTPCONNECTION_BACKEND_IFACE_H_

#define _NNTPCONNECTION_BACKEND_IFACE_H_

#include 

#include 

#ifdef WIN32

#include 

#else

#include 

#endif

#include "configuration.h"

#include "collections.h"

G_BEGIN_DECLS

typedef enum {

    NNTP_JOB_TYPE_NONE,

    NNTP_JOB_TYPE_ARTICLE,

    NNTP_JOB_TYPE_XOVER

} NNTPJobType;

typedef enum {

    NNTP_CONNECTION_ERROR_NONE,

    NNTP_CONNECTION_ERROR_HOST_NOT_FOUND,

    NNTP_CONNECTION_ERROR_SSL_INITIALISE,

    NNTP_CONNECTION_ERROR_CONNECTION_REFUSED,

    NNTP_CONNECTION_ERROR_CONNECTION_TIMEOUT,

    NNTP_CONNECTION_ERROR_READ,

    NNTP_CONNECTION_ERROR_WRITE,

    NNTP_CONNECTION_ERROR_INVALID_MSG,

    NNTP_CONNECTION_ERROR_INVALID_ARGUMENT,

    NNTP_CONNECTION_ERROR_LOGIN_FAILURE,

    NNTP_CONNECTION_ERROR_TOO_MANY_CONNECTIONS,

    NNTP_CONNECTION_ERROR_PART_NOT_AVAILABLE,

    NNTP_CONNECTION_ERROR_NO_SUCH_GROUP,

    NNTP_CONNECTION_ERROR_UNABLE_TO_SAVE_PART,

} NNTPConnectionErrCode;

#define NNTP_TYPE_CONNECTION                (nntpconnection_get_type ())

#define NNTP_CONNECTION(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), NNTP_TYPE_CONNECTION, NntpConnection))

#define NNTP_IS_CONNECTION(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NNTP_TYPE_CONNECTION))

#define NNTPCONNECTION_TYPE_BACKEND                (nntpconnection_backend_get_type ())

#define NNTPCONNECTION_BACKEND(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), NNTPCONNECTION_TYPE_BACKEND, NntpconnectionBackend))

#define NNTPCONNECTION_IS_BACKEND(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NNTPCONNECTION_TYPE_BACKEND))

#define NNTPCONNECTION_BACKEND_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), NNTPCONNECTION_TYPE_BACKEND, NntpconnectionBackendIface))

typedef struct _NntpConnection NntpConnection;

typedef struct _NntpConnectionClass NntpConnectionClass;

typedef struct _NntpconnectionBackend NntpconnectionBackend;    /* dummy interface */

typedef struct _NntpconnectionBackendIface NntpconnectionBackendIface;

struct _NntpConnection {

    GObject parent;

    int connection_id;

    int server_id;

    NGConfigServer server_info;

    GPollFD poll_fd;

    void (*active_method) (NntpConnection *conn);

    int max_bandwidth;

    gboolean is_idle;

    time_t idle_start_stamp;

    time_t last_checked_stamp;

    time_t last_disconnect_stamp;

    time_t last_activity_stamp;

    NNTPJobType job_type;

    NNTPCollection *collection;

    NNTPFile *file;

    NNTPPart *part;

    char newsgroup[256];

    gint64 xover_start_range;

    gint64 xover_end_range;

    char article_filename[1024];

    int article_fd;

    int article_bytes_downloaded;

    struct timeval last_article_progress_announce;

    char article_write_buffer[50000];              /* Flush the received article data every 50.000 bytes, GObject doesn't support larger objects */

    int article_write_buffer_length;

};

struct _NntpconnectionBackendIface {

    GTypeInterface parent;

    NNTPConnectionErrCode (*connect) (NntpConnection *self, const char *hostname, int port, char **errmsg);

    void (*disconnect) (NntpConnection *self);

    gboolean (*prepare_ssl) (NntpConnection *conn, char **errmsg);

    gboolean (*ensure_data_is_ready) (NntpConnection *conn, int timeout);

    gboolean (*read_msg) (NntpConnection *conn, gboolean read_line, int max_length, void *data, int *data_length, gboolean *more_data_ready, gboolean *try_again, char **errmsg);

    gboolean (*send_msg) (NntpConnection *conn, void *data, int length, char **errmsg);

    gboolean (*get_has_ssl_support) (NntpConnection *conn);

};

GType nntpconnection_get_type (void);

GType nntpconnection_backend_get_type (void);

void nntpconnection_backend_init_traffic_monitor(void);

void nntpconnection_backend_update_traffic_monitor(int bytes_read);

void nntpconnection_backend_perform_shaping(int max_bandwidth, int bytes_read);

/* Wrapper functions */

NNTPConnectionErrCode nntpconnection_backend_connect(NntpConnection *conn, const char *hostname, int port, char **errmsg);

void nntpconnection_backend_disconnect(NntpConnection *conn);

gboolean nntpconnection_backend_prepare_ssl(NntpConnection *conn);

/* Public functions */

gboolean nntpconnection_get_has_ssl_support(NntpConnection *conn);

NNTPConnectionErrCode nntpconnection_connect_to_server(NntpConnection *conn, char **errmsg);

void nntpconnection_disconnect_from_server(NntpConnection *conn, NNTPDisconnectType disconnect_type, const char *reason, const char *cause_file, int cause_lineno);

gboolean nntpconnection_ensure_data_is_ready(NntpConnection *conn, int timeout);

gboolean nntpconnection_read_msg(NntpConnection *conn, gboolean read_line, int max_length, void *data, int *data_length, gboolean *more_data_ready);

gboolean nntpconnection_send_msg(NntpConnection *conn, void *data, int length);

gboolean nntpconnection_get_has_ssl_support(NntpConnection *conn);

void nntpconnection_process_proxy_connect_command(NntpConnection *conn);

G_END_DECLS

#endif /* _NNTPCONNECTION_BACKEND_IFACE_H_ */

/*

    Copyright (C) 2005-2010  Erik van Pienbroek

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#ifndef _QUEUE_RAWFILE_H_

#define _QUEUE_RAWFILE_H_

#include "collections.h"

#include 

gboolean     queue_rawfile_load(GList **queue_ret, char **errmsg);

gboolean     queue_rawfile_save(GList *queue, char **errmsg);

#endif /* _QUEUE_RAWFILE_H_ */

/*

    Copyright (C) 2005-2011  Erik van Pienbroek

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#ifdef HAVE_GIO_SOCKET

#include 

#include 

#include "nntpconnection_backend_gio.h"

#include "nntpgrab_plugin.h"

struct _NntpconnectionBackendGioPrivate {

    GMainLoop *loop;

    GSocketConnectable *connectable;

    GSocket *socket;

    GIOStream *connection;

    GDataInputStream *istream;

    GOutputStream *ostream;

};

struct _NntpconnectionBackendGioClass {

    GObjectClass parent_class;

    /* define vtable methods and signals here */

};

static void nntpconnection_backend_gio_disconnect(NntpConnection *conn);

static void nntpconnection_backend_gio_iface_init(NntpconnectionBackendIface *iface);

static void nntpconnection_backend_gio_init (NntpconnectionBackendGio *self)

{

    self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, NNTPCONNECTION_TYPE_BACKEND_GIO, NntpconnectionBackendGioPrivate);

    self->priv->loop = g_main_loop_new(NULL, FALSE);

}

static void nntpconnection_backend_gio_class_init (NntpconnectionBackendGioClass *klass)

{

    g_type_class_add_private (klass, sizeof (NntpconnectionBackendGioPrivate));

}

G_DEFINE_TYPE_WITH_CODE (NntpconnectionBackendGio, nntpconnection_backend_gio, NNTP_TYPE_CONNECTION,

                         G_IMPLEMENT_INTERFACE(NNTPCONNECTION_TYPE_BACKEND, nntpconnection_backend_gio_iface_init))

NntpConnection *nntpconnection_backend_gio_new (void)

{

    ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_INFO, "Created NNTP connection using backend 'gio'");

    return NNTP_CONNECTION(g_object_new(NNTPCONNECTION_TYPE_BACKEND_GIO, NULL));

}

static NNTPConnectionErrCode

nntpconnection_backend_gio_connect(NntpConnection *conn, const char *hostname, int port, char **errmsg)

{

    NntpconnectionBackendGioPrivate *conn_priv = NNTPCONNECTION_BACKEND_GIO(conn)->priv;

    GError *err = NULL;

    GSocketAddressEnumerator *enumerator;

    GSocketAddress *address;

    GCancellable *cancellable = NULL;

    g_return_val_if_fail(conn != NULL, NNTP_CONNECTION_ERROR_INVALID_ARGUMENT);

    g_return_val_if_fail(conn->poll_fd.fd == -1, NNTP_CONNECTION_ERROR_INVALID_ARGUMENT);

    g_return_val_if_fail(hostname != NULL, NNTP_CONNECTION_ERROR_INVALID_ARGUMENT);

    g_return_val_if_fail(port > 0, NNTP_CONNECTION_ERROR_INVALID_ARGUMENT);

    g_return_val_if_fail(conn_priv != NULL, NNTP_CONNECTION_ERROR_INVALID_ARGUMENT);

    g_return_val_if_fail(errmsg != NULL, NNTP_CONNECTION_ERROR_INVALID_ARGUMENT);

    g_return_val_if_fail(*errmsg == NULL, NNTP_CONNECTION_ERROR_INVALID_ARGUMENT);

    conn_priv->socket = g_socket_new(G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_STREAM, 0, &err);

    if (!conn_priv->socket) {

        *errmsg = g_strdup_printf("g_socket_new() FAILED: %s", err->message);

        g_error_free(err);

        return NNTP_CONNECTION_ERROR_INVALID_ARGUMENT;

    }

    g_socket_set_timeout(conn_priv->socket, 30);

    conn_priv->connectable = g_network_address_parse(hostname, port, &err);

    if (!conn_priv->connectable) {

        *errmsg = g_strdup_printf("Unable to parse hostname '%s' and port '%i': %s", hostname, port, err->message);

        g_error_free(err);

        nntpconnection_backend_gio_disconnect(conn);

        return NNTP_CONNECTION_ERROR_HOST_NOT_FOUND;

    }

    enumerator = g_socket_connectable_enumerate(conn_priv->connectable);

    while (TRUE) {

        address = g_socket_address_enumerator_next (enumerator, cancellable, &err);

        if (!address) {

#if 0

            if (err == NULL)

                g_printerr ("%s: No more addresses to try\n", argv[0]);

            else

                g_printerr ("%s: %s\n", argv[0], error->message);

#endif

            return 1;

        }

        if (g_socket_connect(conn_priv->socket, address, cancellable, &err))

            break;

        //g_printerr ("%s: Connection to %s failed: %s, trying next\n", argv[0], socket_address_to_string (address), err->message);

        g_error_free (err);

        err = NULL;

        g_object_unref (address);

    }

    g_object_unref (enumerator);

    /* Keep the GSocketConnectable around if we still need to set up SSL later */

    if (!conn->server_info.use_ssl) {

        g_object_unref(conn_priv->connectable);

        conn_priv->connectable = NULL;

    }

    conn_priv->connection = G_IO_STREAM (g_socket_connection_factory_create_connection(conn_priv->socket));

    conn_priv->istream = g_data_input_stream_new(g_io_stream_get_input_stream(conn_priv->connection));

    conn_priv->ostream = g_io_stream_get_output_stream(conn_priv->connection);

    g_socket_set_blocking(conn_priv->socket, FALSE);

    g_data_input_stream_set_newline_type(G_DATA_INPUT_STREAM(conn_priv->istream), G_DATA_STREAM_NEWLINE_TYPE_CR_LF);

    conn->poll_fd.fd = g_socket_get_fd(conn_priv->socket);

    return NNTP_CONNECTION_ERROR_NONE;

}

static void

nntpconnection_backend_gio_disconnect(NntpConnection *conn)

{

    NntpconnectionBackendGioPrivate *conn_priv = NNTPCONNECTION_BACKEND_GIO(conn)->priv;

    g_return_if_fail(conn != NULL);

    g_return_if_fail(conn_priv != NULL);

    if (conn_priv->socket) {

        g_object_unref(conn_priv->socket);

        conn_priv->socket = NULL;

    }

}

static gboolean

accept_certificate (GTlsClientConnection *conn, GTlsCertificate *cert,

                    GTlsCertificateFlags errors, gpointer user_data)

{

    g_print ("Certificate would have been rejected ( ");

    if (errors & G_TLS_CERTIFICATE_UNKNOWN_CA)

        g_print ("unknown-ca ");

    if (errors & G_TLS_CERTIFICATE_BAD_IDENTITY)

        g_print ("bad-identity ");

    if (errors & G_TLS_CERTIFICATE_NOT_ACTIVATED)

        g_print ("not-activated ");

    if (errors & G_TLS_CERTIFICATE_EXPIRED)

        g_print ("expired ");

    if (errors & G_TLS_CERTIFICATE_REVOKED)

        g_print ("revoked ");

    if (errors & G_TLS_CERTIFICATE_INSECURE)

        g_print ("insecure ");

    g_print (") but accepting anyway.\n");

    return TRUE;

}

static gboolean

nntpconnection_backend_gio_prepare_ssl (NntpConnection *conn, char **errmsg)

{

#if GLIB_CHECK_VERSION(2,28,0)

    GError *err = NULL;

    NntpconnectionBackendGioPrivate *conn_priv;

    GIOStream *tls_conn;

    g_return_val_if_fail(conn != NULL, FALSE);

    g_return_val_if_fail(conn->server_info.use_ssl == TRUE, FALSE);

    g_return_val_if_fail(errmsg != NULL, FALSE);

    g_return_val_if_fail(*errmsg == NULL, FALSE);

    conn_priv = NNTPCONNECTION_BACKEND_GIO(conn)->priv;

    g_return_val_if_fail(conn_priv != NULL, FALSE);

    g_return_val_if_fail(conn_priv->connection != NULL, FALSE);

    g_return_val_if_fail(conn_priv->connectable != NULL, FALSE);

    tls_conn = g_tls_client_connection_new (conn_priv->connection, conn_priv->connectable, &err);

    if (!tls_conn) {

        *errmsg = g_strdup_printf("Could not create TLS connection: %s\n", err->message);

        g_error_free(err);

        return FALSE;

    }

    g_signal_connect (tls_conn, "accept-certificate", G_CALLBACK (accept_certificate), NULL);

    if (!g_tls_connection_handshake (G_TLS_CONNECTION (tls_conn), NULL, &err)) {

        *errmsg = g_strdup_printf("Error during TLS handshake: %s\n", err->message);

        g_error_free(err);

        return FALSE;

    }

    /* Replace the already known streams with the TLS based one */

    g_object_unref(conn_priv->connection);

    g_filter_input_stream_set_close_base_stream(G_FILTER_INPUT_STREAM(conn_priv->istream), FALSE);

    g_object_unref(conn_priv->istream);

    conn_priv->connection = G_IO_STREAM(tls_conn);

    conn_priv->istream = g_data_input_stream_new(g_io_stream_get_input_stream(conn_priv->connection));

    conn_priv->ostream = g_io_stream_get_output_stream(conn_priv->connection);

    g_data_input_stream_set_newline_type(G_DATA_INPUT_STREAM(conn_priv->istream), G_DATA_STREAM_NEWLINE_TYPE_CR_LF);

    g_object_unref(conn_priv->connectable);

    conn_priv->connectable = NULL;

    return TRUE;

#else

    *errmsg = g_strdup("This version of GIO doesn't have SSL/TLS support");

    return FALSE;

#endif

}

static gboolean

source_ready (GPollableInputStream *stream,

              gpointer              data)

{

    NntpconnectionBackendGioPrivate *conn_priv = (NntpconnectionBackendGioPrivate*) data;

    g_main_loop_quit (conn_priv->loop);

    return FALSE;

}

static void

ensure_connection_condition (NntpConnection *conn,

                             GIOCondition    condition,

                             GCancellable   *cancellable)

{

    NntpconnectionBackendGioPrivate *conn_priv = NNTPCONNECTION_BACKEND_GIO(conn)->priv;

    GSource *source;

    if (condition & G_IO_IN)

        source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (g_io_stream_get_input_stream (conn_priv->connection)), cancellable);

    else

        source = g_pollable_output_stream_create_source (G_POLLABLE_OUTPUT_STREAM (g_io_stream_get_output_stream (conn_priv->connection)), cancellable);

    g_source_set_callback (source, (GSourceFunc) source_ready, conn_priv, NULL);

    g_source_attach (source, NULL);

    g_source_unref (source);

    g_main_loop_run (conn_priv->loop);

}

struct _cancel_data {

    GCancellable *cancellable;

    int timeout;

};

static gpointer

cancel_thread (gpointer data)

{

    struct _cancel_data *cancel_data = (struct _cancel_data*) data;

    g_usleep(cancel_data->timeout);

    g_print("Cancelling\n");

    g_cancellable_cancel(cancel_data->cancellable);

    g_slice_free1(sizeof(struct _cancel_data), cancel_data);

    return NULL;

}

static gboolean

nntpconnection_backend_gio_ensure_data_is_ready(NntpConnection *conn, int timeout)

{

    GCancellable *cancellable = NULL;

    gboolean ret;

    if (timeout > 0) {

        static GCancellable *cancellable_cached = NULL;

        struct _cancel_data *cancel_data = g_slice_alloc(sizeof(struct _cancel_data));

        if (!cancellable_cached) {

            cancellable_cached = g_cancellable_new();

        }

        cancellable = cancellable_cached;

        cancel_data->cancellable = cancellable_cached;

        cancel_data->timeout = timeout;

        g_thread_create(cancel_thread, cancel_data, FALSE, NULL);

    }

    ensure_connection_condition (conn, G_IO_IN, cancellable);

    ret = !(g_cancellable_is_cancelled(cancellable));

    g_cancellable_reset(cancellable);

    return ret;

}

static gboolean

nntpconnection_backend_gio_read_msg(NntpConnection *conn, gboolean read_line, int max_length, void *data, int *data_length, gboolean *more_data_ready, gboolean *try_again, char **errmsg)

{

    NntpconnectionBackendGioPrivate *conn_priv;

    GError *err = NULL;

    gsize len;

    char *line;

    g_return_val_if_fail(conn != NULL, FALSE);

    g_return_val_if_fail(max_length > 0, FALSE);

    g_return_val_if_fail(data != NULL, FALSE);

    g_return_val_if_fail(data_length != NULL, FALSE);

    g_return_val_if_fail(*data_length == 0, FALSE);

    /* more_data_ready can be NULL */

    g_return_val_if_fail(try_again != NULL, FALSE);

    g_return_val_if_fail(errmsg != NULL, FALSE);

    g_return_val_if_fail(*errmsg == NULL, FALSE);

    conn_priv = NNTPCONNECTION_BACKEND_GIO(conn)->priv;

    g_return_val_if_fail(conn_priv != NULL, FALSE);

    *try_again = FALSE;

    if (read_line) {

        line = g_data_input_stream_read_line(G_DATA_INPUT_STREAM(conn_priv->istream), &len, NULL, &err);

    } else {

        line = g_data_input_stream_read_upto(G_DATA_INPUT_STREAM(conn_priv->istream), "\n", -1, &len, NULL, &err);

        if (line) {

            /* Also read the \n character itself */

            g_return_val_if_fail(g_data_input_stream_read_byte(G_DATA_INPUT_STREAM(conn_priv->istream), NULL, NULL) == '\n', FALSE);

        }

    }

    if (line) {

        /* NOTE: len will include the newline characters when read_line == FALSE, otherwise len will be 0 when an empty line was received */

        if (len > max_length) {

            ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_INFO, "nntpconnection_backend_gio_read_msg: Very long line received from server. Ignoring\nLine = %s", line);

            g_free(line);

            return FALSE;

        }

        memcpy(data, line, len);

        /* g_data_input_stream_read_upto doesn't put the \n character in the buffer. Manually add this when read_line == FALSE */

        if (!read_line && len + 1 < max_length) {

            char *data_ptr = (char*) data;

            data_ptr[len] = '\n';

            data_ptr[len + 1] = '\0';

            len += 1;

        }

        g_free(line);

    } else {

        len = -1;

    }

    if (len == -1) {

        g_return_val_if_fail(err != NULL, FALSE);

        if (err->code == G_IO_ERROR_WOULD_BLOCK) {

            *try_again = TRUE;

        }

        *errmsg = g_strdup(err->message);

        g_error_free(err);

        return FALSE;

    } else {

        *data_length = len;

        nntpconnection_backend_perform_shaping(conn->max_bandwidth, len);

        nntpconnection_backend_update_traffic_monitor(len);

    }

    if (more_data_ready) {

        *more_data_ready = (g_buffered_input_stream_get_available(G_BUFFERED_INPUT_STREAM(conn_priv->istream)) > 0);

    }

    return TRUE;

}

static gboolean

nntpconnection_backend_gio_send_msg(NntpConnection *conn, void *data, int length, char **errmsg)

{

    NntpconnectionBackendGioPrivate *conn_priv;

    GError *err = NULL;

    gboolean ret;

    g_return_val_if_fail(conn != NULL, FALSE);

    conn_priv = NNTPCONNECTION_BACKEND_GIO(conn)->priv;

    g_return_val_if_fail(conn_priv != NULL, FALSE);

    ret = g_output_stream_write_all(G_OUTPUT_STREAM(conn_priv->ostream), data, length, NULL, NULL, &err);

    if (!ret) {

        *errmsg = g_strdup(err->message);

        g_error_free(err);

        return FALSE;

    }

    return TRUE;

}

static gboolean

nntpconnection_backend_gio_get_has_ssl_support(NntpConnection *conn)

{

#if GLIB_CHECK_VERSION(2,28,0)

    return g_tls_backend_supports_tls(g_tls_backend_get_default());

#else

    return FALSE;

#endif

}

static void nntpconnection_backend_gio_iface_init(NntpconnectionBackendIface *iface)

{

    iface->connect = nntpconnection_backend_gio_connect;

    iface->disconnect = nntpconnection_backend_gio_disconnect;

    iface->prepare_ssl = nntpconnection_backend_gio_prepare_ssl;

    iface->ensure_data_is_ready = nntpconnection_backend_gio_ensure_data_is_ready;

    iface->read_msg = nntpconnection_backend_gio_read_msg;

    iface->send_msg = nntpconnection_backend_gio_send_msg;

    iface->get_has_ssl_support = nntpconnection_backend_gio_get_has_ssl_support;

}

#endif

/*

    Copyright (C) 2005-2010  Erik van Pienbroek

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include 

#include "nntpgrab_types.h"

#include "collections.h"

#include "collection_alloc.h"

NNTPFile *

file_new(void)

{

    NNTPFile *file = g_slice_new0(NNTPFile);

    file_ref(file);

    return file;

}

void

file_ref(NNTPFile *file)

{

    g_atomic_int_inc(&file->refcount);

//    g_print("file_ref: refcount = %i for subject %s\n", file->refcount, file->subject);

}

void

file_unref(NNTPFile *file)

{

    GList *groups;

    GList *parts;

    if (!g_atomic_int_dec_and_test(&file->refcount)) {

//        g_print("file_unref: refcount = %i for subject %s\n", file->refcount, file->subject);

        return;

    }

//    g_print("file_unref: refcount = %i for subject %s\n", file->refcount, file->subject);

//    g_print("releasing file\n");

    groups = file->groups;

    while (groups) {

        g_free(groups->data);

        groups = g_list_next(groups);

    }

    g_list_free(file->groups);

    parts = file->parts;

    while (parts) {

        g_slice_free(NNTPPart, parts->data);

        parts = g_list_next(parts);

    }

    g_list_free(file->parts);

    g_slice_free(NNTPFile, file);

}

NNTPCollection *

collection_new(void)

{

    NNTPCollection *collection = g_slice_new0(NNTPCollection);

    g_static_mutex_init(&collection->mutex);

    collection_ref(collection);

    return collection;

}

void

collection_ref(NNTPCollection *collection)

{

    g_atomic_int_inc(&collection->refcount);

//    g_print("collection_ref: refcount = %i for collection %s\n", collection->refcount, collection->collection_name);

}

void

collection_unref(NNTPCollection *collection)

{

    GList *files;

    if (!g_atomic_int_dec_and_test(&collection->refcount)) {

//        g_print("collection_unref: refcount = %i for collection %s\n", collection->refcount, collection->collection_name);

        return;

    }

//    g_print("collection_unref: refcount = %i for collection %s\n", collection->refcount, collection->collection_name);

//    g_print("releasing collection\n");

    files = collection->files;

    while (files) {

        NNTPFile *file = (NNTPFile *) files->data;

        file_unref(file);

        files = g_list_next(files);

    }

    g_list_free(collection->files);

    g_list_free(collection->files_to_download);

    g_slice_free(NNTPCollection, collection);

}

/*

    Copyright (C) 2005-2010  Erik van Pienbroek

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

/* Parts of this file are taken from ProFTP's throttle.c */

#include 

#include 

#include 

#include 

#include 

#ifdef WIN32

#include 

#endif

#include "nntpgrab.h"

#include "nntpgrab_plugin.h"

/* This allows a throttling process to be killed by the admin */

#ifndef WIN32

static void

xfer_rate_sigmask(int block)

{

    static sigset_t sig_set;

    if (block) {

        sigemptyset(&sig_set);

        sigaddset(&sig_set, SIGCHLD);

        sigaddset(&sig_set, SIGUSR1);

        sigaddset(&sig_set, SIGINT);

        sigaddset(&sig_set, SIGQUIT);

#ifdef SIGIO

        sigaddset(&sig_set, SIGIO);

#endif /* SIGIO */

#ifdef SIGBUS

        sigaddset(&sig_set, SIGBUS);

#endif /* SIGBUS */

        sigaddset(&sig_set, SIGHUP);

        while (sigprocmask(SIG_BLOCK, &sig_set, NULL) < 0) {

            if (errno == EINTR) {

                continue;

            }

            break;

        }

    } else {

        while (sigprocmask(SIG_UNBLOCK, &sig_set, NULL) < 0) {

            if (errno == EINTR) {

                continue;

            }

            break;

        }

    }

}

#endif

/* Returns the difference, in milliseconds, between the given timeval and now */

static long

xfer_rate_since(struct timeval *then)

{

    struct timeval now;

    gettimeofday(&now, NULL);

    return (((now.tv_sec - then->tv_sec) * 1000L) + ((now.tv_usec - then->tv_usec) / 1000L));

}

void

throttle_pause(struct timeval start_time, off_t xferlen, int max_bandwidth)

{

    long double xfer_rate_bps;

    long ideal = 0, elapsed = 0;

    /* Calculate the time interval since the transfer of data started. */

    elapsed = xfer_rate_since(&start_time);

    xfer_rate_bps = max_bandwidth * 1024.0;

    ideal = (xferlen * 1000L) / xfer_rate_bps;

    if (ideal > elapsed) {

        struct timeval tv;

        /* Setup for the select.  We use select() instead of usleep() because it

         * seems to be far more portable across platforms.

         *

         * ideal and elapsed are in milleconds, but tv_usec will be microseconds,

         * so be sure to convert properly.

         */

        tv.tv_usec = (ideal - elapsed) * 1000;

        tv.tv_sec = tv.tv_usec / 1000000L;

        tv.tv_usec = tv.tv_usec % 1000000L;

#if 0

        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "transferring too fast, delaying %ld sec%s, %ld usecs",

            (long int) tv.tv_sec, tv.tv_sec == 1 ? "" : "s", (long int) tv.tv_usec);

#endif

#ifdef WIN32

        /* Stupid Win32 doesn't support the select() function with no sockets attached.. */

        Sleep(ideal - elapsed);

#else

        /* No interruptions, please... */

        xfer_rate_sigmask(TRUE);

        if (select(0, NULL, NULL, NULL, &tv) < 0) {

            ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_WARNING, "warning: unable to throttle bandwidth: %s", strerror(errno));

        }

        xfer_rate_sigmask(FALSE);

#endif

    }

    return;

}

/* Convert a string representation of time to a time value.

   Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   Contributed by Ulrich Drepper , 1996.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Library General Public License as

   published by the Free Software Foundation; either version 2 of the

   License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public

   License along with the GNU C Library; see the file COPYING.LIB.  If not,

   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

/* XXX This version of the implementation is not really complete.

   Some of the fields cannot add information alone.  But if seeing

   some of them in the same format (such as year, week and weekday)

   this is enough information for determining the date.  */

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#ifdef WIN32

#define strncasecmp            strnicmp

#endif

#include 

#include 

#include 

#include 

#ifdef _LIBC

# include "../locale/localeinfo.h"

#endif

#include "strptime.h"

#ifndef __P

# if defined (__GNUC__) || (defined (__STDC__) && __STDC__)

#  define __P(args) args

# else

#  define __P(args) ()

# endif  /* GCC.  */

#endif  /* Not __P.  */

#if ! HAVE_LOCALTIME_R && ! defined localtime_r

# ifdef _LIBC

#  define localtime_r __localtime_r

# else

/* Approximate localtime_r as best we can in its absence.  */

#  define localtime_r my_localtime_r

static struct tm *localtime_r __P ((const time_t *, struct tm *));

static struct tm *

localtime_r (t, tp)

     const time_t *t;

     struct tm *tp;

{

  struct tm *l = localtime (t);

  if (! l)

    return 0;

  *tp = *l;

  return tp;

}

# endif /* ! _LIBC */

#endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */

#define match_char(ch1, ch2) if (ch1 != ch2) return NULL

#if defined __GNUC__ && __GNUC__ >= 2

# define match_string(cs1, s2) \

  ({ size_t len = strlen (cs1);                                                      \

     int result = strncasecmp ((cs1), (s2), len) == 0;                       \

     if (result) (s2) += len;                                                \

     result; })

#else

/* Oh come on.  Get a reasonable compiler.  */

# define match_string(cs1, s2) \

  (strncasecmp ((cs1), (s2), strlen (cs1)) ? 0 : ((s2) += strlen (cs1), 1))

#endif

/* We intentionally do not use isdigit() for testing because this will

   lead to problems with the wide character version.  */

#define get_number(from, to, n) \

  do {                                                                       \

    int __n = n;                                                             \

    val = 0;                                                                 \

    while (*rp == ' ')                                                       \

      ++rp;                                                                  \

    if (*rp < '0' || *rp > '9')                                                \

      return NULL;                                                           \

    do {                                                                     \

      val *= 10;                                                             \

      val += *rp++ - '0';                                                    \

    } while (--__n > 0 && val * 10 <= to && *rp >= '0' && *rp <= '9');           \

    if (val < from || val > to)                                                \

      return NULL;                                                           \

  } while (0)

#ifdef _NL_CURRENT

# define get_alt_number(from, to, n) \

  ({                                                                         \

    __label__ do_normal;                                                     \

    if (*decided != raw)                                                     \

      {                                                                              \

        const char *alts = _NL_CURRENT (LC_TIME, ALT_DIGITS);                \

        int __n = n;                                                         \

        int any = 0;                                                         \

        while (*rp == ' ')                                                   \

          ++rp;                                                                      \

        val = 0;                                                             \

        do {                                                                 \

          val *= 10;                                                         \

          while (*alts != '\0')                                                      \

            {                                                                \

              size_t len = strlen (alts);                                    \

              if (strncasecmp (alts, rp, len) == 0)                          \

                break;                                                       \

              alts += len + 1;                                               \

              ++val;                                                         \

            }                                                                \

          if (*alts == '\0')                                                 \

            {                                                                \

              if (*decided == not && ! any)                                  \

                goto do_normal;                                                      \

              /* If we haven't read anything it's an error.  */                      \

              if (! any)                                                     \

                return NULL;                                                 \

              /* Correct the premature multiplication.  */                   \

              val /= 10;                                                     \

              break;                                                         \

            }                                                                \

          else                                                               \

            *decided = loc;                                                  \

        } while (--__n > 0 && val * 10 <= to);                                 \

        if (val < from || val > to)                                            \

          return NULL;                                                       \

      }                                                                              \

    else                                                                     \

      {                                                                              \

       do_normal:                                                            \

        get_number (from, to, n);                                            \

      }                                                                              \

    0;                                                                       \

  })

#else

# define get_alt_number(from, to, n) \

  /* We don't have the alternate representation.  */                         \

  get_number(from, to, n)

#endif

#define recursive(new_fmt) \

  (*(new_fmt) != '\0'                                                        \

   && (rp = strptime_internal (rp, (new_fmt), tm, decided, era_cnt)) != NULL)

#ifdef _LIBC

/* This is defined in locale/C-time.c in the GNU libc.  */

extern const struct locale_data _nl_C_LC_TIME;

extern const unsigned short int __mon_yday[2][13];

# define weekday_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (DAY_1)].string)

# define ab_weekday_name \

  (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABDAY_1)].string)

# define month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (MON_1)].string)

# define ab_month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABMON_1)].string)

# define HERE_D_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_T_FMT)].string)

# define HERE_D_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_FMT)].string)

# define HERE_AM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (AM_STR)].string)

# define HERE_PM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (PM_STR)].string)

# define HERE_T_FMT_AMPM \

  (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT_AMPM)].string)

# define HERE_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT)].string)

# define strncasecmp(s1, s2, n) __strncasecmp (s1, s2, n)

#else

static char const weekday_name[][10] =

  {

    "Sunday", "Monday", "Tuesday", "Wednesday",

    "Thursday", "Friday", "Saturday"

  };

static char const ab_weekday_name[][4] =

  {

    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"

  };

static char const month_name[][10] =

  {

    "January", "February", "March", "April", "May", "June",

    "July", "August", "September", "October", "November", "December"

  };

static char const ab_month_name[][4] =

  {

    "Jan", "Feb", "Mar", "Apr", "May", "Jun",

    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"

  };

# define HERE_D_T_FMT "%a %b %e %H:%M:%S %Y"

# define HERE_D_FMT "%m/%d/%y"

# define HERE_AM_STR "AM"

# define HERE_PM_STR "PM"

# define HERE_T_FMT_AMPM "%I:%M:%S %p"

# define HERE_T_FMT "%H:%M:%S"

const unsigned short int __mon_yday[2][13] =

  {

    /* Normal years.  */

    { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },

    /* Leap years.  */

    { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }

  };

#endif

/* Status of lookup: do we use the locale data or the raw data?  */

enum locale_status { not, loc, raw };

#ifndef __isleap

/* Nonzero if YEAR is a leap year (every 4 years,

   except every 100th isn't, and every 400th is).  */

# define __isleap(year)        \

  ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))

#endif

/* Compute the day of the week.  */

static void

day_of_the_week (struct tm *tm)

{

  /* We know that January 1st 1970 was a Thursday (= 4).  Compute the

     the difference between this data in the one on TM and so determine

     the weekday.  */

  int corr_year = 1900 + tm->tm_year - (tm->tm_mon < 2);

  int wday = (-473

              + (365 * (tm->tm_year - 70))

              + (corr_year / 4)

              - ((corr_year / 4) / 25) + ((corr_year / 4) % 25 < 0)

              + (((corr_year / 4) / 25) / 4)

              + __mon_yday[0][tm->tm_mon]

              + tm->tm_mday - 1);

  tm->tm_wday = ((wday % 7) + 7) % 7;

}

/* Compute the day of the year.  */

static void

day_of_the_year (struct tm *tm)

{

  tm->tm_yday = (__mon_yday[__isleap (1900 + tm->tm_year)][tm->tm_mon]

                 + (tm->tm_mday - 1));

}

static char *

#ifdef _LIBC

internal_function

#endif

strptime_internal __P ((const char *rp, const char *fmt, struct tm *tm,

                        enum locale_status *decided, int era_cnt));

static char *

#ifdef _LIBC

internal_function

#endif

strptime_internal (rp, fmt, tm, decided, era_cnt)

     const char *rp;

     const char *fmt;

     struct tm *tm;

     enum locale_status *decided;

     int era_cnt;

{

  int cnt;

  size_t val;

  int have_I, is_pm;

  int century, want_century;

  int want_era;

  int have_wday, want_xday;

  int have_yday;

  int have_mon, have_mday;

#ifdef _NL_CURRENT

  const char *rp_backup;

  size_t num_eras;

  struct era_entry *era;

#endif

  have_I = is_pm = 0;

  century = -1;

  want_century = 0;

  want_era = 0;

#ifdef _NL_CURRENT

  era = NULL;

#endif

  have_wday = want_xday = have_yday = have_mon = have_mday = 0;

  while (*fmt != '\0')

    {

      /* A white space in the format string matches 0 more or white

         space in the input string.  */

      if (isspace (*fmt))

        {

          while (isspace (*rp))

            ++rp;

          ++fmt;

          continue;

        }

      /* Any character but `%' must be matched by the same character

         in the iput string.  */

      if (*fmt != '%')

        {

          match_char (*fmt++, *rp++);

          continue;

        }

      ++fmt;

#ifndef _NL_CURRENT

      /* We need this for handling the `E' modifier.  */

    start_over:

#endif

#ifdef _NL_CURRENT

      /* Make back up of current processing pointer.  */

      rp_backup = rp;

#endif

      switch (*fmt++)

        {

        case '%':

          /* Match the `%' character itself.  */

          match_char ('%', *rp++);

          break;

        case 'a':

        case 'A':

          /* Match day of week.  */

          for (cnt = 0; cnt < 7; ++cnt)

            {

#ifdef _NL_CURRENT

              if (*decided !=raw)

                {

                  if (match_string (_NL_CURRENT (LC_TIME, DAY_1 + cnt), rp))

                    {

                      if (*decided == not

                          && strcmp (_NL_CURRENT (LC_TIME, DAY_1 + cnt),

                                     weekday_name[cnt]))

                        *decided = loc;

                      break;

                    }

                  if (match_string (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt), rp))

                    {

                      if (*decided == not

                          && strcmp (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt),

                                     ab_weekday_name[cnt]))

                        *decided = loc;

                      break;

                    }

                }

#endif

              if (*decided != loc

                  && (match_string (weekday_name[cnt], rp)

                      || match_string (ab_weekday_name[cnt], rp)))

                {

                  *decided = raw;

                  break;

                }

            }

          if (cnt == 7)

            /* Does not match a weekday name.  */

            return NULL;

          tm->tm_wday = cnt;

          have_wday = 1;

          break;

        case 'b':

        case 'B':

        case 'h':

          /* Match month name.  */

          for (cnt = 0; cnt < 12; ++cnt)

            {

#ifdef _NL_CURRENT

              if (*decided !=raw)

                {

                  if (match_string (_NL_CURRENT (LC_TIME, MON_1 + cnt), rp))

                    {

                      if (*decided == not

                          && strcmp (_NL_CURRENT (LC_TIME, MON_1 + cnt),

                                     month_name[cnt]))

                        *decided = loc;

                      break;

                    }

                  if (match_string (_NL_CURRENT (LC_TIME, ABMON_1 + cnt), rp))

                    {

                      if (*decided == not

                          && strcmp (_NL_CURRENT (LC_TIME, ABMON_1 + cnt),

                                     ab_month_name[cnt]))

                        *decided = loc;

                      break;

                    }

                }

#endif

              if (match_string (month_name[cnt], rp)

                  || match_string (ab_month_name[cnt], rp))

                {

                  *decided = raw;

                  break;

                }

            }

          if (cnt == 12)

            /* Does not match a month name.  */

            return NULL;

          tm->tm_mon = cnt;

          want_xday = 1;

          break;

        case 'c':

          /* Match locale's date and time format.  */

#ifdef _NL_CURRENT

          if (*decided != raw)

            {

              if (!recursive (_NL_CURRENT (LC_TIME, D_T_FMT)))

                {

                  if (*decided == loc)

                    return NULL;

                  else

                    rp = rp_backup;

                }

              else

                {

                  if (*decided == not &&

                      strcmp (_NL_CURRENT (LC_TIME, D_T_FMT), HERE_D_T_FMT))

                    *decided = loc;

                  want_xday = 1;

                  break;

                }

              *decided = raw;

            }

#endif

          if (!recursive (HERE_D_T_FMT))

            return NULL;

          want_xday = 1;

          break;

        case 'C':

          /* Match century number.  */

#ifdef _NL_CURRENT

        match_century:

#endif

          get_number (0, 99, 2);

          century = val;

          want_xday = 1;

          break;

        case 'd':

        case 'e':

          /* Match day of month.  */

          get_number (1, 31, 2);

          tm->tm_mday = val;

          have_mday = 1;

          want_xday = 1;

          break;

        case 'F':

          if (!recursive ("%Y-%m-%d"))

            return NULL;

          want_xday = 1;

          break;

        case 'x':

#ifdef _NL_CURRENT

          if (*decided != raw)

            {

              if (!recursive (_NL_CURRENT (LC_TIME, D_FMT)))

                {

                  if (*decided == loc)

                    return NULL;

                  else

                    rp = rp_backup;

                }

              else

                {

                  if (*decided == not

                      && strcmp (_NL_CURRENT (LC_TIME, D_FMT), HERE_D_FMT))

                    *decided = loc;

                  want_xday = 1;

                  break;

                }

              *decided = raw;

            }

#endif

          /* Fall through.  */

        case 'D':

          /* Match standard day format.  */

          if (!recursive (HERE_D_FMT))

            return NULL;

          want_xday = 1;

          break;

        case 'k':

        case 'H':

          /* Match hour in 24-hour clock.  */

          get_number (0, 23, 2);

          tm->tm_hour = val;

          have_I = 0;

          break;

        case 'I':

          /* Match hour in 12-hour clock.  */

          get_number (1, 12, 2);

          tm->tm_hour = val % 12;

          have_I = 1;

          break;

        case 'j':

          /* Match day number of year.  */

          get_number (1, 366, 3);

          tm->tm_yday = val - 1;

          have_yday = 1;

          break;

        case 'm':