src/miranda/miranda-media.c

   1 /**
   2  * @file miranda-media.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-2016 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <windows.h>
  24 #include <stdio.h>
  25
  26 #include <glib.h>
  27
  28 #include "newpluginapi.h"
  29 #include "m_protosvc.h"
  30 #include "m_protoint.h"
  31
  32 #include "sipe-common.h"
  33 #include "sipe-backend.h"
  34 #include "sipe-core.h"
  35 #include "miranda-private.h"
  36
  37 struct sipe_backend_media {
  38         int dummy;
  39 };
  40
  41 struct sipe_backend_media *
  42 sipe_backend_media_new(struct sipe_core_public *sipe_public,
  43                        struct sipe_media_call *call,
  44                        const gchar *participant,
  45                        SipeMediaCallFlags flags)
  46 {
  47         struct sipe_backend_media *m = g_new0(struct sipe_backend_media,1);
  48
  49         return m;
  50 }
  51
  52 void
  53 sipe_backend_media_free(struct sipe_backend_media *media)
  54 {
  55         _NIF();
  56 }
  57
  58 void
  59 sipe_backend_media_set_cname(struct sipe_backend_media *media, gchar *cname)
  60 {
  61         _NIF();
  62 }
  63
  64 struct sipe_backend_media_relays *
  65 sipe_backend_media_relays_convert(GSList *media_relays, gchar *username, gchar *password)
  66 {
  67         _NIF();
  68         return NULL;
  69 }
  70
  71 void
  72 sipe_backend_media_relays_free(struct sipe_backend_media_relays *media_relays)
  73 {
  74         _NIF();
  75 }
  76
  77 struct sipe_backend_media_stream *
  78 sipe_backend_media_add_stream(struct sipe_media_stream *stream,
  79                               SipeMediaType type,
  80                               SipeIceVersion ice_version,
  81                               gboolean initiator,
  82                               struct sipe_backend_media_relays *media_relays,
  83                               guint min_port, guint max_port)
  84 {
  85         _NIF();
  86         return NULL;
  87 }
  88
  89 void
  90 sipe_backend_media_add_remote_candidates(struct sipe_media_call *media,
  91                                          struct sipe_media_stream *stream,
  92                                          GList *candidates)
  93 {
  94         _NIF();
  95 }
  96
  97 gboolean sipe_backend_media_is_initiator(struct sipe_media_call *media,
  98                                          struct sipe_media_stream *stream)
  99 {
 100         _NIF();
 101         return FALSE;
 102 }
 103
 104 gboolean sipe_backend_media_accepted(struct sipe_backend_media *media)
 105 {
 106         _NIF();
 107         return FALSE;
 108 }
 109
 110 gboolean
 111 sipe_backend_stream_initialized(struct sipe_media_call *media,
 112                                 struct sipe_media_stream *stream)
 113 {
 114         _NIF();
 115         return FALSE;
 116 }
 117
 118 GList *
 119 sipe_backend_media_stream_get_active_local_candidates(struct sipe_media_stream *stream)
 120 {
 121         _NIF();
 122         return NULL;
 123 }
 124
 125 GList *
 126 sipe_backend_media_stream_get_active_remote_candidates(struct sipe_media_stream *stream)
 127 {
 128         _NIF();
 129         return NULL;
 130 }
 131
 132 sipe_backend_media_set_encryption_keys(struct sipe_media_call *media,
 133                                        struct sipe_media_stream *stream,
 134                                        const guchar *encryption_key,
 135                                        const guchar *decryption_key)
 136 {
 137         _NIF();
 138 }
 139
 140 void
 141 sipe_backend_media_set_require_encryption(struct sipe_media_call *media,
 142                                           struct sipe_media_stream *stream,
 143                                           const gboolean require_encryption)
 144 {
 145         _NIF();
 146 }
 147
 148 void
 149 sipe_backend_stream_hold(struct sipe_media_call *media,
 150                          struct sipe_media_stream *stream,
 151                          gboolean local)
 152 {
 153         _NIF();
 154 }
 155
 156 void
 157 sipe_backend_stream_unhold(struct sipe_media_call *media,
 158                            struct sipe_media_stream *stream,
 159                            gboolean local)
 160 {
 161         _NIF();
 162 }
 163
 164 gboolean
 165 sipe_backend_stream_is_held(struct sipe_media_stream *stream)
 166 {
 167         _NIF();
 168         return FALSE;
 169 }
 170
 171 void
 172 sipe_backend_media_stream_end(struct sipe_media_call *media,
 173                               struct sipe_media_stream *stream)
 174 {
 175         _NIF();
 176 }
 177
 178 void
 179 sipe_backend_media_stream_free(struct sipe_backend_media_stream *stream)
 180 {
 181         _NIF();
 182 }
 183
 184 struct sipe_backend_codec *
 185 sipe_backend_codec_new(int id, const char *name, SipeMediaType type,
 186                        guint clock_rate, guint channels)
 187 {
 188         _NIF();
 189         return NULL;
 190 }
 191
 192 void
 193 sipe_backend_codec_free(struct sipe_backend_codec *codec)
 194 {
 195         _NIF();
 196 }
 197
 198 int
 199 sipe_backend_codec_get_id(struct sipe_backend_codec *codec)
 200 {
 201         _NIF();
 202         return 0;
 203 }
 204
 205 gchar *
 206 sipe_backend_codec_get_name(struct sipe_backend_codec *codec)
 207 {
 208         _NIF();
 209         return NULL;
 210 }
 211
 212 guint
 213 sipe_backend_codec_get_clock_rate(struct sipe_backend_codec *codec)
 214 {
 215         _NIF();
 216         return 0;
 217 }
 218
 219 void
 220 sipe_backend_codec_add_optional_parameter(struct sipe_backend_codec *codec,
 221                                           const gchar *name, const gchar *value)
 222 {
 223         _NIF();
 224 }
 225
 226 GList *
 227 sipe_backend_codec_get_optional_parameters(struct sipe_backend_codec *codec)
 228 {
 229         _NIF();
 230         return NULL;
 231 }
 232
 233 gboolean
 234 sipe_backend_set_remote_codecs(struct sipe_media_call *media,
 235                                struct sipe_media_stream *stream,
 236                                GList *codecs)
 237 {
 238         _NIF();
 239         return FALSE;
 240 }
 241
 242 GList*
 243 sipe_backend_get_local_codecs(struct sipe_media_call *media,
 244                               struct sipe_media_stream *stream)
 245 {
 246         _NIF();
 247         return NULL;
 248 }
 249
 250 struct sipe_backend_candidate *
 251 sipe_backend_candidate_new(const gchar *foundation,
 252                            SipeComponentType component,
 253                            SipeCandidateType type, SipeNetworkProtocol proto,
 254                            const gchar *ip, guint port,
 255                            const gchar *username,
 256                            const gchar *password)
 257 {
 258         _NIF();
 259         return NULL;
 260 }
 261
 262 void
 263 sipe_backend_candidate_free(struct sipe_backend_candidate *candidate)
 264 {
 265         _NIF();
 266 }
 267
 268 gchar *
 269 sipe_backend_candidate_get_username(struct sipe_backend_candidate *candidate)
 270 {
 271         _NIF();
 272         return NULL;
 273 }
 274
 275 gchar *
 276 sipe_backend_candidate_get_password(struct sipe_backend_candidate *candidate)
 277 {
 278         _NIF();
 279         return NULL;
 280 }
 281
 282 gchar *
 283 sipe_backend_candidate_get_foundation(struct sipe_backend_candidate *candidate)
 284 {
 285         _NIF();
 286         return NULL;
 287 }
 288
 289 gchar *
 290 sipe_backend_candidate_get_ip(struct sipe_backend_candidate *candidate)
 291 {
 292         _NIF();
 293         return NULL;
 294 }
 295
 296 guint
 297 sipe_backend_candidate_get_port(struct sipe_backend_candidate *candidate)
 298 {
 299         _NIF();
 300         return 0;
 301 }
 302
 303 gchar *
 304 sipe_backend_candidate_get_base_ip(struct sipe_backend_candidate *candidate)
 305 {
 306         _NIF();
 307         return FALSE;
 308 }
 309
 310 guint
 311 sipe_backend_candidate_get_base_port(struct sipe_backend_candidate *candidate)
 312 {
 313         _NIF();
 314         return 0;
 315 }
 316
 317 guint32
 318 sipe_backend_candidate_get_priority(struct sipe_backend_candidate *candidate)
 319 {
 320         _NIF();
 321         return 0;
 322 }
 323
 324 void
 325 sipe_backend_candidate_set_priority(struct sipe_backend_candidate *candidate, guint32 priority)
 326 {
 327         _NIF();
 328 }
 329
 330 SipeComponentType
 331 sipe_backend_candidate_get_component_type(struct sipe_backend_candidate *candidate)
 332 {
 333         _NIF();
 334         return SIPE_COMPONENT_NONE;
 335 }
 336
 337 SipeCandidateType
 338 sipe_backend_candidate_get_type(struct sipe_backend_candidate *candidate)
 339 {
 340         _NIF();
 341         return SIPE_CANDIDATE_TYPE_ANY;
 342 }
 343
 344 SipeNetworkProtocol
 345 sipe_backend_candidate_get_protocol(struct sipe_backend_candidate *candidate)
 346 {
 347         _NIF();
 348         return SIPE_NETWORK_PROTOCOL_TCP_ACTIVE;
 349 }
 350
 351 GList *
 352 sipe_backend_get_local_candidates(struct sipe_media_call *media,
 353                                   struct sipe_media_stream *stream)
 354 {
 355         _NIF();
 356         return FALSE;
 357 }
 358
 359 void
 360 sipe_backend_media_accept(struct sipe_backend_media *media, gboolean local)
 361 {
 362         _NIF();
 363 }
 364
 365 void
 366 sipe_backend_media_hangup(struct sipe_backend_media *media, gboolean local)
 367 {
 368         _NIF();
 369 }
 370
 371 void
 372 sipe_backend_media_reject(struct sipe_backend_media *media, gboolean local)
 373 {
 374         _NIF();
 375 }
 376
 377 SipeEncryptionPolicy
 378 sipe_backend_media_get_encryption_policy(struct sipe_core_public *sipe_public)
 379 {
 380         return SIPE_ENCRYPTION_POLICY_REJECTED;
 381 }
 382
 383 gssize
 384 sipe_backend_media_stream_read(struct sipe_media_stream *stream,
 385                                guint8 *buffer, gsize len)
 386 {
 387         _NIF();
 388 }
 389
 390 gssize
 391 sipe_backend_media_stream_write(struct sipe_media_stream *stream,
 392                                 guint8 *buffer, gsize len)
 393 {
 394         _NIF();
 395 }
 396
 397 /*
 398   Local Variables:
 399   mode: c
 400   c-file-style: "bsd"
 401   indent-tabs-mode: t
 402   tab-width: 8
 403   End:
 404 */