git.gag.com Git - debian/amanda/blob - xfer-src/xfer-element.c

   1 /*
   2  * Amanda, The Advanced Maryland Automatic Network Disk Archiver
   3  * Copyright (c) 2008, 2009, 2010 Zmanda, Inc.  All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published
   7  * by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17  *
  18  * Contact information: Zmanda Inc., 465 S. Mathilda Ave., Suite 300
  19  * Sunnyvale, CA 94085, USA, or: http://www.zmanda.com
  20  */
  21
  22 #include "amanda.h"
  23 #include "amxfer.h"
  24
  25 /* parent class for XferElement */
  26 static GObjectClass *parent_class = NULL;
  27
  28 /* parent class for XferDest, XferFilter, and XferSource */
  29 static XferElementClass *xfer_element_class = NULL;
  30
  31 /***********************
  32  * XferElement */
  33
  34 static void
  35 xfer_element_init(
  36     XferElement *xe)
  37 {
  38     xe->xfer = NULL;
  39     xe->output_mech = XFER_MECH_NONE;
  40     xe->input_mech = XFER_MECH_NONE;
  41     xe->upstream = xe->downstream = NULL;
  42     xe->_input_fd = xe->_output_fd = -1;
  43     xe->repr = NULL;
  44 }
  45
  46 static gboolean
  47 xfer_element_setup_impl(
  48     XferElement *elt G_GNUC_UNUSED)
  49 {
  50     return TRUE; /* success */
  51 }
  52
  53 static gboolean
  54 xfer_element_start_impl(
  55     XferElement *elt G_GNUC_UNUSED)
  56 {
  57     return FALSE; /* will not send XMSG_DONE */
  58 }
  59
  60 static gboolean
  61 xfer_element_cancel_impl(
  62     XferElement *elt,
  63     gboolean expect_eof)
  64 {
  65     elt->cancelled = TRUE;
  66     elt->expect_eof = expect_eof;
  67     return elt->can_generate_eof;
  68 }
  69
  70 static gpointer
  71 xfer_element_pull_buffer_impl(
  72     XferElement *elt G_GNUC_UNUSED,
  73     size_t *size G_GNUC_UNUSED)
  74 {
  75     return NULL;
  76 }
  77
  78 static void
  79 xfer_element_push_buffer_impl(
  80     XferElement *elt G_GNUC_UNUSED,
  81     gpointer buf G_GNUC_UNUSED,
  82     size_t size G_GNUC_UNUSED)
  83 {
  84 }
  85
  86 static xfer_element_mech_pair_t *
  87 xfer_element_get_mech_pairs_impl(
  88     XferElement *elt)
  89 {
  90     return XFER_ELEMENT_GET_CLASS(elt)->mech_pairs;
  91 }
  92
  93 static char *
  94 xfer_element_repr_impl(
  95     XferElement *elt)
  96 {
  97     if (!elt->repr) {
  98         elt->repr = newvstrallocf(elt->repr, "<%s@%p>",
  99                 G_OBJECT_TYPE_NAME(G_OBJECT(elt)),
 100                 elt);
 101     }
 102
 103     return elt->repr;
 104 }
 105
 106 static void
 107 xfer_element_finalize(
 108     GObject * obj_self)
 109 {
 110     XferElement *elt = XFER_ELEMENT(obj_self);
 111     gint fd;
 112
 113     /* free the repr cache */
 114     if (elt->repr) g_free(elt->repr);
 115
 116     /* close up the input/output file descriptors, being careful to do so
 117      * atomically, and making any errors doing so into mere warnings */
 118     fd = xfer_element_swap_input_fd(elt, -1);
 119     if (fd != -1 && close(fd) != 0)
 120         g_warning("error closing fd %d: %s", fd, strerror(errno));
 121     fd = xfer_element_swap_output_fd(elt, -1);
 122     if (fd != -1 && close(fd) != 0)
 123         g_warning("error closing fd %d: %s", fd, strerror(errno));
 124
 125     /* chain up */
 126     G_OBJECT_CLASS(parent_class)->finalize(obj_self);
 127 }
 128
 129 static void
 130 xfer_element_class_init(
 131     XferElementClass * klass)
 132 {
 133     GObjectClass *goc = (GObjectClass*) klass;
 134
 135     klass->repr = xfer_element_repr_impl;
 136     klass->setup = xfer_element_setup_impl;
 137     klass->start = xfer_element_start_impl;
 138     klass->cancel = xfer_element_cancel_impl;
 139     klass->pull_buffer = xfer_element_pull_buffer_impl;
 140     klass->push_buffer = xfer_element_push_buffer_impl;
 141     klass->get_mech_pairs = xfer_element_get_mech_pairs_impl;
 142
 143     goc->finalize = xfer_element_finalize;
 144
 145     klass->perl_class = NULL;
 146
 147     parent_class = g_type_class_peek_parent(klass);
 148     xfer_element_class = klass;
 149 }
 150
 151 GType
 152 xfer_element_get_type(void)
 153 {
 154     static GType type = 0;
 155
 156     if G_UNLIKELY(type == 0) {
 157         static const GTypeInfo info = {
 158             sizeof (XferElementClass),
 159             (GBaseInitFunc) NULL,
 160             (GBaseFinalizeFunc) NULL,
 161             (GClassInitFunc) xfer_element_class_init,
 162             (GClassFinalizeFunc) NULL,
 163             NULL /* class_data */,
 164             sizeof (XferElement),
 165             0 /* n_preallocs */,
 166             (GInstanceInitFunc) xfer_element_init,
 167             NULL
 168         };
 169
 170         type = g_type_register_static (G_TYPE_OBJECT, "XferElement", &info,
 171                                        (GTypeFlags)G_TYPE_FLAG_ABSTRACT);
 172     }
 173
 174     return type;
 175 }
 176
 177 /*
 178  * Method stubs
 179  */
 180
 181 void
 182 xfer_element_unref(
 183     XferElement *elt)
 184 {
 185     if (elt) g_object_unref(elt);
 186 }
 187
 188 char *
 189 xfer_element_repr(
 190     XferElement *elt)
 191 {
 192     return XFER_ELEMENT_GET_CLASS(elt)->repr(elt);
 193 }
 194
 195 gboolean
 196 xfer_element_setup(
 197     XferElement *elt)
 198 {
 199     return XFER_ELEMENT_GET_CLASS(elt)->setup(elt);
 200 }
 201
 202 gboolean
 203 xfer_element_start(
 204     XferElement *elt)
 205 {
 206     return XFER_ELEMENT_GET_CLASS(elt)->start(elt);
 207 }
 208
 209 gboolean
 210 xfer_element_cancel(
 211     XferElement *elt,
 212     gboolean expect_eof)
 213 {
 214     return XFER_ELEMENT_GET_CLASS(elt)->cancel(elt, expect_eof);
 215 }
 216
 217 gpointer
 218 xfer_element_pull_buffer(
 219     XferElement *elt,
 220     size_t *size)
 221 {
 222     /* Make sure that the xfer is running before calling upstream's
 223      * pull_buffer method; this avoids a race condition where upstream
 224      * hasn't finished its xfer_element_start yet, and isn't ready for
 225      * a pull */
 226     if (elt->xfer->status == XFER_START)
 227         wait_until_xfer_running(elt->xfer);
 228
 229     return XFER_ELEMENT_GET_CLASS(elt)->pull_buffer(elt, size);
 230 }
 231
 232 void
 233 xfer_element_push_buffer(
 234     XferElement *elt,
 235     gpointer buf,
 236     size_t size)
 237 {
 238     /* There is no race condition with push_buffer, because downstream
 239      * elements are started first. */
 240     XFER_ELEMENT_GET_CLASS(elt)->push_buffer(elt, buf, size);
 241 }
 242
 243 xfer_element_mech_pair_t *
 244 xfer_element_get_mech_pairs(
 245         XferElement *elt)
 246 {
 247     return XFER_ELEMENT_GET_CLASS(elt)->get_mech_pairs(elt);
 248 }
 249
 250 /****
 251  * Utilities
 252  */
 253
 254 void
 255 xfer_element_drain_by_pulling(
 256     XferElement *upstream)
 257 {
 258     gpointer buf;
 259     size_t size;
 260
 261     while ((buf =xfer_element_pull_buffer(upstream, &size))) {
 262         amfree(buf);
 263     }
 264 }
 265
 266 void
 267 xfer_element_drain_by_reading(
 268     int fd)
 269 {
 270     size_t len;
 271     char buf[1024];
 272
 273     while (1) {
 274         len = full_read(fd, buf, sizeof(buf));
 275         if (len < sizeof(buf))
 276             return;
 277     }
 278 }
 279