src/dma/vendor/github.com/libvirt/libvirt-go/stream_wrapper.go

   1 /*
   2  * This file is part of the libvirt-go project
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20  * THE SOFTWARE.
  21  *
  22  * Copyright (c) 2013 Alex Zorin
  23  * Copyright (C) 2016 Red Hat, Inc.
  24  *
  25  */
  26
  27 package libvirt
  28
  29 /*
  30 #cgo pkg-config: libvirt
  31 #include <stdint.h>
  32 #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 int streamSourceHoleCallback(virStreamPtr st, int *inData, long long *length, int callbackID);
  38 int streamSourceSkipCallback(virStreamPtr st, long long length, int callbackID);
  39
  40 int streamSinkCallback(virStreamPtr st, const char *cdata, size_t nbytes, int callbackID);
  41 int streamSinkHoleCallback(virStreamPtr st, long long length, int callbackID);
  42
  43 struct CallbackData {
  44     int callbackID;
  45     int holeCallbackID;
  46     int skipCallbackID;
  47 };
  48
  49 static int streamSourceCallbackHelper(virStreamPtr st, char *data, size_t nbytes, void *opaque)
  50 {
  51     struct CallbackData *cbdata = opaque;
  52
  53     return streamSourceCallback(st, data, nbytes, cbdata->callbackID);
  54 }
  55
  56 static int streamSourceHoleCallbackHelper(virStreamPtr st, int *inData, long long *length, void *opaque)
  57 {
  58     struct CallbackData *cbdata = opaque;
  59
  60     return streamSourceHoleCallback(st, inData, length, cbdata->holeCallbackID);
  61 }
  62
  63 static int streamSourceSkipCallbackHelper(virStreamPtr st, long long length, void *opaque)
  64 {
  65     struct CallbackData *cbdata = opaque;
  66
  67     return streamSourceSkipCallback(st, length, cbdata->skipCallbackID);
  68 }
  69
  70 static int streamSinkCallbackHelper(virStreamPtr st, const char *data, size_t nbytes, void *opaque)
  71 {
  72     struct CallbackData *cbdata = opaque;
  73
  74     return streamSinkCallback(st, data, nbytes, cbdata->callbackID);
  75 }
  76
  77 static int streamSinkHoleCallbackHelper(virStreamPtr st, long long length, void *opaque)
  78 {
  79     struct CallbackData *cbdata = opaque;
  80
  81     return streamSinkHoleCallback(st, length, cbdata->holeCallbackID);
  82 }
  83
  84 int
  85 virStreamAbortWrapper(virStreamPtr stream,
  86                       virErrorPtr err)
  87 {
  88     int ret = virStreamAbort(stream);
  89     if (ret < 0) {
  90         virCopyLastError(err);
  91     }
  92     return ret;
  93 }
  94
  95
  96 void
  97 streamEventCallback(virStreamPtr st, int events, int callbackID);
  98
  99 static void
 100 streamEventCallbackHelper(virStreamPtr st, int events, void *opaque)
 101 {
 102     streamEventCallback(st, events, (int)(intptr_t)opaque);
 103 }
 104
 105 int
 106 virStreamEventAddCallbackWrapper(virStreamPtr stream,
 107                                  int events,
 108                                  int callbackID,
 109                                  virErrorPtr err)
 110 {
 111     int ret = virStreamEventAddCallback(stream, events, streamEventCallbackHelper, (void *)(intptr_t)callbackID, NULL);
 112     if (ret < 0) {
 113         virCopyLastError(err);
 114     }
 115     return ret;
 116 }
 117
 118
 119 int
 120 virStreamEventRemoveCallbackWrapper(virStreamPtr stream,
 121                                     virErrorPtr err)
 122 {
 123     int ret = virStreamEventRemoveCallback(stream);
 124     if (ret < 0) {
 125         virCopyLastError(err);
 126     }
 127     return ret;
 128 }
 129
 130
 131 int
 132 virStreamEventUpdateCallbackWrapper(virStreamPtr stream,
 133                                     int events,
 134                                     virErrorPtr err)
 135 {
 136     int ret = virStreamEventUpdateCallback(stream, events);
 137     if (ret < 0) {
 138         virCopyLastError(err);
 139     }
 140     return ret;
 141 }
 142
 143
 144 int
 145 virStreamFinishWrapper(virStreamPtr stream,
 146                        virErrorPtr err)
 147 {
 148     int ret = virStreamFinish(stream);
 149     if (ret < 0) {
 150         virCopyLastError(err);
 151     }
 152     return ret;
 153 }
 154
 155
 156 int
 157 virStreamFreeWrapper(virStreamPtr stream,
 158                      virErrorPtr err)
 159 {
 160     int ret = virStreamFree(stream);
 161     if (ret < 0) {
 162         virCopyLastError(err);
 163     }
 164     return ret;
 165 }
 166
 167
 168 int
 169 virStreamRecvWrapper(virStreamPtr stream,
 170                      char *data,
 171                      size_t nbytes,
 172                      virErrorPtr err)
 173 {
 174     int ret = virStreamRecv(stream, data, nbytes);
 175     if (ret < 0) {
 176         virCopyLastError(err);
 177     }
 178     return ret;
 179 }
 180
 181
 182 int
 183 virStreamRecvAllWrapper(virStreamPtr stream,
 184                         int callbackID,
 185                         virErrorPtr err)
 186 {
 187     struct CallbackData cbdata = { .callbackID = callbackID };
 188     int ret = virStreamRecvAll(stream, streamSinkCallbackHelper, &cbdata);
 189     if (ret < 0) {
 190         virCopyLastError(err);
 191     }
 192     return ret;
 193 }
 194
 195
 196 int
 197 virStreamRecvFlagsWrapper(virStreamPtr stream,
 198                           char *data,
 199                           size_t nbytes,
 200                           unsigned int flags,
 201                           virErrorPtr err)
 202 {
 203 #if LIBVIR_VERSION_NUMBER < 3004000
 204     assert(0); // Caller should have checked version
 205 #else
 206     int ret = virStreamRecvFlags(stream, data, nbytes, flags);
 207     if (ret < 0) {
 208         virCopyLastError(err);
 209     }
 210     return ret;
 211 #endif
 212 }
 213
 214
 215 int
 216 virStreamRecvHoleWrapper(virStreamPtr stream,
 217                          long long *length,
 218                          unsigned int flags,
 219                          virErrorPtr err)
 220 {
 221 #if LIBVIR_VERSION_NUMBER < 3004000
 222     assert(0); // Caller should have checked version
 223 #else
 224     int ret = virStreamRecvHole(stream, length, flags);
 225     if (ret < 0) {
 226         virCopyLastError(err);
 227     }
 228     return ret;
 229 #endif
 230 }
 231
 232
 233 int
 234 virStreamRefWrapper(virStreamPtr stream,
 235                     virErrorPtr err)
 236 {
 237     int ret = virStreamRef(stream);
 238     if (ret < 0) {
 239         virCopyLastError(err);
 240     }
 241     return ret;
 242 }
 243
 244
 245 int
 246 virStreamSendWrapper(virStreamPtr stream,
 247                      const char *data,
 248                      size_t nbytes,
 249                      virErrorPtr err)
 250 {
 251     int ret = virStreamSend(stream, data, nbytes);
 252     if (ret < 0) {
 253         virCopyLastError(err);
 254     }
 255     return ret;
 256 }
 257
 258
 259 int
 260 virStreamSendAllWrapper(virStreamPtr stream,
 261                         int callbackID,
 262                         virErrorPtr err)
 263 {
 264     struct CallbackData cbdata = { .callbackID = callbackID };
 265     int ret = virStreamSendAll(stream, streamSourceCallbackHelper, &cbdata);
 266     if (ret < 0) {
 267         virCopyLastError(err);
 268     }
 269     return ret;
 270 }
 271
 272
 273 int
 274 virStreamSendHoleWrapper(virStreamPtr stream,
 275                          long long length,
 276                          unsigned int flags,
 277                          virErrorPtr err)
 278 {
 279 #if LIBVIR_VERSION_NUMBER < 3004000
 280     assert(0); // Caller should have checked version
 281 #else
 282     int ret = virStreamSendHole(stream, length, flags);
 283     if (ret < 0) {
 284         virCopyLastError(err);
 285     }
 286     return ret;
 287 #endif
 288 }
 289
 290
 291 int
 292 virStreamSparseRecvAllWrapper(virStreamPtr stream,
 293                               int callbackID,
 294                               int holeCallbackID,
 295                               virErrorPtr err)
 296 {
 297     struct CallbackData cbdata = { .callbackID = callbackID, .holeCallbackID = holeCallbackID };
 298 #if LIBVIR_VERSION_NUMBER < 3004000
 299     assert(0); // Caller should have checked version
 300 #else
 301     int ret = virStreamSparseRecvAll(stream, streamSinkCallbackHelper, streamSinkHoleCallbackHelper, &cbdata);
 302     if (ret < 0) {
 303         virCopyLastError(err);
 304     }
 305     return ret;
 306 #endif
 307 }
 308
 309
 310 int
 311 virStreamSparseSendAllWrapper(virStreamPtr stream,
 312                               int callbackID,
 313                               int holeCallbackID,
 314                               int skipCallbackID,
 315                               virErrorPtr err)
 316 {
 317     struct CallbackData cbdata = { .callbackID = callbackID, .holeCallbackID = holeCallbackID, .skipCallbackID = skipCallbackID };
 318 #if LIBVIR_VERSION_NUMBER < 3004000
 319     assert(0); // Caller should have checked version
 320 #else
 321     int ret = virStreamSparseSendAll(stream, streamSourceCallbackHelper, streamSourceHoleCallbackHelper, streamSourceSkipCallbackHelper, &cbdata);
 322     if (ret < 0) {
 323         virCopyLastError(err);
 324     }
 325     return ret;
 326 #endif
 327 }
 328
 329
 330 */
 331 import "C"