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 "amxfer.h"
  23 #include "amanda.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
 112     /* free the repr cache */
 113     if (elt->repr) g_free(elt->repr);
 114
 115     /* chain up */
 116     G_OBJECT_CLASS(parent_class)->finalize(obj_self);
 117 }
 118
 119 static void
 120 xfer_element_class_init(
 121     XferElementClass * klass)
 122 {
 123     GObjectClass *goc = (GObjectClass*) klass;
 124
 125     klass->repr = xfer_element_repr_impl;
 126     klass->setup = xfer_element_setup_impl;
 127     klass->start = xfer_element_start_impl;
 128     klass->cancel = xfer_element_cancel_impl;
 129     klass->pull_buffer = xfer_element_pull_buffer_impl;
 130     klass->push_buffer = xfer_element_push_buffer_impl;
 131     klass->get_mech_pairs = xfer_element_get_mech_pairs_impl;
 132
 133     goc->finalize = xfer_element_finalize;
 134
 135     klass->perl_class = NULL;
 136
 137     parent_class = g_type_class_peek_parent(klass);
 138     xfer_element_class = klass;
 139 }
 140
 141 GType
 142 xfer_element_get_type(void)
 143 {
 144     static GType type = 0;
 145
 146     if G_UNLIKELY(type == 0) {
 147         static const GTypeInfo info = {
 148             sizeof (XferElementClass),
 149             (GBaseInitFunc) NULL,
 150             (GBaseFinalizeFunc) NULL,
 151             (GClassInitFunc) xfer_element_class_init,
 152             (GClassFinalizeFunc) NULL,
 153             NULL /* class_data */,
 154             sizeof (XferElement),
 155             0 /* n_preallocs */,
 156             (GInstanceInitFunc) xfer_element_init,
 157             NULL
 158         };
 159
 160         type = g_type_register_static (G_TYPE_OBJECT, "XferElement", &info,
 161                                        (GTypeFlags)G_TYPE_FLAG_ABSTRACT);
 162     }
 163
 164     return type;
 165 }
 166
 167 /*
 168  * Method stubs
 169  */
 170
 171 void
 172 xfer_element_unref(
 173     XferElement *elt)
 174 {
 175     if (elt) g_object_unref(elt);
 176 }
 177
 178 char *
 179 xfer_element_repr(
 180     XferElement *elt)
 181 {
 182     return XFER_ELEMENT_GET_CLASS(elt)->repr(elt);
 183 }
 184
 185 gboolean
 186 xfer_element_setup(
 187     XferElement *elt)
 188 {
 189     return XFER_ELEMENT_GET_CLASS(elt)->setup(elt);
 190 }
 191
 192 gboolean
 193 xfer_element_start(
 194     XferElement *elt)
 195 {
 196     return XFER_ELEMENT_GET_CLASS(elt)->start(elt);
 197 }
 198
 199 gboolean
 200 xfer_element_cancel(
 201     XferElement *elt,
 202     gboolean expect_eof)
 203 {
 204     return XFER_ELEMENT_GET_CLASS(elt)->cancel(elt, expect_eof);
 205 }
 206
 207 gpointer
 208 xfer_element_pull_buffer(
 209     XferElement *elt,
 210     size_t *size)
 211 {
 212     /* Make sure that the xfer is running before calling upstream's
 213      * pull_buffer method; this avoids a race condition where upstream
 214      * hasn't finished its xfer_element_start yet, and isn't ready for
 215      * a pull */
 216     if (elt->xfer->status == XFER_START)
 217         wait_until_xfer_running(elt->xfer);
 218
 219     return XFER_ELEMENT_GET_CLASS(elt)->pull_buffer(elt, size);
 220 }
 221
 222 void
 223 xfer_element_push_buffer(
 224     XferElement *elt,
 225     gpointer buf,
 226     size_t size)
 227 {
 228     /* There is no race condition with push_buffer, because downstream
 229      * elements are started first. */
 230     XFER_ELEMENT_GET_CLASS(elt)->push_buffer(elt, buf, size);
 231 }
 232
 233 xfer_element_mech_pair_t *
 234 xfer_element_get_mech_pairs(
 235         XferElement *elt)
 236 {
 237     return XFER_ELEMENT_GET_CLASS(elt)->get_mech_pairs(elt);
 238 }
 239
 240 /****
 241  * Utilities
 242  */
 243
 244 void
 245 xfer_element_drain_by_pulling(
 246     XferElement *upstream)
 247 {
 248     gpointer buf;
 249     size_t size;
 250
 251     while ((buf =xfer_element_pull_buffer(upstream, &size))) {
 252         amfree(buf);
 253     }
 254 }
 255
 256 void
 257 xfer_element_drain_by_reading(
 258     int fd)
 259 {
 260     size_t len;
 261     char buf[1024];
 262
 263     while (1) {
 264         len = full_read(fd, buf, sizeof(buf));
 265         if (len < sizeof(buf))
 266             return;
 267     }
 268 }
 269