stream_wrapper.go 8.58 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
/*
 * This file is part of the libvirt-go project
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 * Copyright (c) 2013 Alex Zorin
 * Copyright (C) 2016 Red Hat, Inc.
 *
 */

package libvirt

/*
#cgo pkg-config: libvirt
31 32
#include <stdint.h>
#include <stdlib.h>
33
#include <assert.h>
34
#include "stream_wrapper.h"
35 36

int streamSourceCallback(virStreamPtr st, char *cdata, size_t nbytes, int callbackID);
37 38 39
int streamSourceHoleCallback(virStreamPtr st, int *inData, long long *length, int callbackID);
int streamSourceSkipCallback(virStreamPtr st, long long length, int callbackID);

40
int streamSinkCallback(virStreamPtr st, const char *cdata, size_t nbytes, int callbackID);
41 42 43 44 45 46 47
int streamSinkHoleCallback(virStreamPtr st, long long length, int callbackID);

struct CallbackData {
    int callbackID;
    int holeCallbackID;
    int skipCallbackID;
};
48 49 50

static int streamSourceCallbackHelper(virStreamPtr st, char *data, size_t nbytes, void *opaque)
{
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
    struct CallbackData *cbdata = opaque;

    return streamSourceCallback(st, data, nbytes, cbdata->callbackID);
}

static int streamSourceHoleCallbackHelper(virStreamPtr st, int *inData, long long *length, void *opaque)
{
    struct CallbackData *cbdata = opaque;

    return streamSourceHoleCallback(st, inData, length, cbdata->holeCallbackID);
}

static int streamSourceSkipCallbackHelper(virStreamPtr st, long long length, void *opaque)
{
    struct CallbackData *cbdata = opaque;
66

67
    return streamSourceSkipCallback(st, length, cbdata->skipCallbackID);
68 69 70 71
}

static int streamSinkCallbackHelper(virStreamPtr st, const char *data, size_t nbytes, void *opaque)
{
72
    struct CallbackData *cbdata = opaque;
73

74 75 76 77 78 79 80 81
    return streamSinkCallback(st, data, nbytes, cbdata->callbackID);
}

static int streamSinkHoleCallbackHelper(virStreamPtr st, long long length, void *opaque)
{
    struct CallbackData *cbdata = opaque;

    return streamSinkHoleCallback(st, length, cbdata->holeCallbackID);
82 83
}

84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
int
virStreamAbortWrapper(virStreamPtr stream,
                      virErrorPtr err)
{
    int ret = virStreamAbort(stream);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
}


void
streamEventCallback(virStreamPtr st, int events, int callbackID);

static void
streamEventCallbackHelper(virStreamPtr st, int events, void *opaque)
{
    streamEventCallback(st, events, (int)(intptr_t)opaque);
}

int
virStreamEventAddCallbackWrapper(virStreamPtr stream,
                                 int events,
                                 int callbackID,
                                 virErrorPtr err)
{
    int ret = virStreamEventAddCallback(stream, events, streamEventCallbackHelper, (void *)(intptr_t)callbackID, NULL);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
}


int
virStreamEventRemoveCallbackWrapper(virStreamPtr stream,
                                    virErrorPtr err)
{
    int ret = virStreamEventRemoveCallback(stream);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
}


int
virStreamEventUpdateCallbackWrapper(virStreamPtr stream,
                                    int events,
                                    virErrorPtr err)
{
    int ret = virStreamEventUpdateCallback(stream, events);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
}


int
virStreamFinishWrapper(virStreamPtr stream,
                       virErrorPtr err)
{
    int ret = virStreamFinish(stream);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
}


int
virStreamFreeWrapper(virStreamPtr stream,
                     virErrorPtr err)
{
    int ret = virStreamFree(stream);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
}


int
virStreamRecvWrapper(virStreamPtr stream,
                     char *data,
                     size_t nbytes,
                     virErrorPtr err)
{
    int ret = virStreamRecv(stream, data, nbytes);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
}


int
virStreamRecvAllWrapper(virStreamPtr stream,
                        int callbackID,
                        virErrorPtr err)
186
{
187
    struct CallbackData cbdata = { .callbackID = callbackID };
188 189 190 191 192
    int ret = virStreamRecvAll(stream, streamSinkCallbackHelper, &cbdata);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
193 194
}

195 196 197 198 199 200 201

int
virStreamRecvFlagsWrapper(virStreamPtr stream,
                          char *data,
                          size_t nbytes,
                          unsigned int flags,
                          virErrorPtr err)
202 203 204 205
{
#if LIBVIR_VERSION_NUMBER < 3004000
    assert(0); // Caller should have checked version
#else
206 207 208 209 210
    int ret = virStreamRecvFlags(stream, data, nbytes, flags);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
211
#endif
212 213 214
}


215 216 217 218 219
int
virStreamRecvHoleWrapper(virStreamPtr stream,
                         long long *length,
                         unsigned int flags,
                         virErrorPtr err)
220 221 222 223
{
#if LIBVIR_VERSION_NUMBER < 3004000
    assert(0); // Caller should have checked version
#else
224 225 226 227 228
    int ret = virStreamRecvHole(stream, length, flags);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
229
#endif
230 231
}

232

233 234 235
int
virStreamRefWrapper(virStreamPtr stream,
                    virErrorPtr err)
236
{
237 238 239 240 241
    int ret = virStreamRef(stream);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
242 243
}

244 245 246 247 248 249

int
virStreamSendWrapper(virStreamPtr stream,
                     const char *data,
                     size_t nbytes,
                     virErrorPtr err)
250
{
251 252 253 254 255
    int ret = virStreamSend(stream, data, nbytes);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
256
}
257

258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277

int
virStreamSendAllWrapper(virStreamPtr stream,
                        int callbackID,
                        virErrorPtr err)
{
    struct CallbackData cbdata = { .callbackID = callbackID };
    int ret = virStreamSendAll(stream, streamSourceCallbackHelper, &cbdata);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
}


int
virStreamSendHoleWrapper(virStreamPtr stream,
                         long long length,
                         unsigned int flags,
                         virErrorPtr err)
278 279 280 281
{
#if LIBVIR_VERSION_NUMBER < 3004000
    assert(0); // Caller should have checked version
#else
282 283 284 285 286
    int ret = virStreamSendHole(stream, length, flags);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
287 288 289
#endif
}

290 291 292 293 294 295

int
virStreamSparseRecvAllWrapper(virStreamPtr stream,
                              int callbackID,
                              int holeCallbackID,
                              virErrorPtr err)
296
{
297
    struct CallbackData cbdata = { .callbackID = callbackID, .holeCallbackID = holeCallbackID };
298 299 300
#if LIBVIR_VERSION_NUMBER < 3004000
    assert(0); // Caller should have checked version
#else
301 302 303 304 305
    int ret = virStreamSparseRecvAll(stream, streamSinkCallbackHelper, streamSinkHoleCallbackHelper, &cbdata);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
306 307 308
#endif
}

309 310 311 312 313 314 315

int
virStreamSparseSendAllWrapper(virStreamPtr stream,
                              int callbackID,
                              int holeCallbackID,
                              int skipCallbackID,
                              virErrorPtr err)
316
{
317
    struct CallbackData cbdata = { .callbackID = callbackID, .holeCallbackID = holeCallbackID, .skipCallbackID = skipCallbackID };
318 319 320
#if LIBVIR_VERSION_NUMBER < 3004000
    assert(0); // Caller should have checked version
#else
321 322 323 324 325
    int ret = virStreamSparseSendAll(stream, streamSourceCallbackHelper, streamSourceHoleCallbackHelper, streamSourceSkipCallbackHelper, &cbdata);
    if (ret < 0) {
        virCopyLastError(err);
    }
    return ret;
326 327 328
#endif
}

329

330 331
*/
import "C"