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_stream_hold(struct sipe_media_call *media,
 142                          struct sipe_media_stream *stream,
 143                          gboolean local)
 144 {
 145         _NIF();
 146 }
 147
 148 void
 149 sipe_backend_stream_unhold(struct sipe_media_call *media,
 150                            struct sipe_media_stream *stream,
 151                            gboolean local)
 152 {
 153         _NIF();
 154 }
 155
 156 gboolean
 157 sipe_backend_stream_is_held(struct sipe_media_stream *stream)
 158 {
 159         _NIF();
 160         return FALSE;
 161 }
 162
 163 void
 164 sipe_backend_media_stream_end(struct sipe_media_call *media,
 165                               struct sipe_media_stream *stream)
 166 {
 167         _NIF();
 168 }
 169
 170 void
 171 sipe_backend_media_stream_free(struct sipe_backend_media_stream *stream)
 172 {
 173         _NIF();
 174 }
 175
 176 struct sipe_backend_codec *
 177 sipe_backend_codec_new(int id, const char *name, SipeMediaType type,
 178                        guint clock_rate, guint channels)
 179 {
 180         _NIF();
 181         return NULL;
 182 }
 183
 184 void
 185 sipe_backend_codec_free(struct sipe_backend_codec *codec)
 186 {
 187         _NIF();
 188 }
 189
 190 int
 191 sipe_backend_codec_get_id(struct sipe_backend_codec *codec)
 192 {
 193         _NIF();
 194         return 0;
 195 }
 196
 197 gchar *
 198 sipe_backend_codec_get_name(struct sipe_backend_codec *codec)
 199 {
 200         _NIF();
 201         return NULL;
 202 }
 203
 204 guint
 205 sipe_backend_codec_get_clock_rate(struct sipe_backend_codec *codec)
 206 {
 207         _NIF();
 208         return 0;
 209 }
 210
 211 void
 212 sipe_backend_codec_add_optional_parameter(struct sipe_backend_codec *codec,
 213                                           const gchar *name, const gchar *value)
 214 {
 215         _NIF();
 216 }
 217
 218 GList *
 219 sipe_backend_codec_get_optional_parameters(struct sipe_backend_codec *codec)
 220 {
 221         _NIF();
 222         return NULL;
 223 }
 224
 225 gboolean
 226 sipe_backend_set_remote_codecs(struct sipe_media_call *media,
 227                                struct sipe_media_stream *stream,
 228                                GList *codecs)
 229 {
 230         _NIF();
 231         return FALSE;
 232 }
 233
 234 GList*
 235 sipe_backend_get_local_codecs(struct sipe_media_call *media,
 236                               struct sipe_media_stream *stream)
 237 {
 238         _NIF();
 239         return NULL;
 240 }
 241
 242 struct sipe_backend_candidate *
 243 sipe_backend_candidate_new(const gchar *foundation,
 244                            SipeComponentType component,
 245                            SipeCandidateType type, SipeNetworkProtocol proto,
 246                            const gchar *ip, guint port,
 247                            const gchar *username,
 248                            const gchar *password)
 249 {
 250         _NIF();
 251         return NULL;
 252 }
 253
 254 void
 255 sipe_backend_candidate_free(struct sipe_backend_candidate *candidate)
 256 {
 257         _NIF();
 258 }
 259
 260 gchar *
 261 sipe_backend_candidate_get_username(struct sipe_backend_candidate *candidate)
 262 {
 263         _NIF();
 264         return NULL;
 265 }
 266
 267 gchar *
 268 sipe_backend_candidate_get_password(struct sipe_backend_candidate *candidate)
 269 {
 270         _NIF();
 271         return NULL;
 272 }
 273
 274 gchar *
 275 sipe_backend_candidate_get_foundation(struct sipe_backend_candidate *candidate)
 276 {
 277         _NIF();
 278         return NULL;
 279 }
 280
 281 gchar *
 282 sipe_backend_candidate_get_ip(struct sipe_backend_candidate *candidate)
 283 {
 284         _NIF();
 285         return NULL;
 286 }
 287
 288 guint
 289 sipe_backend_candidate_get_port(struct sipe_backend_candidate *candidate)
 290 {
 291         _NIF();
 292         return 0;
 293 }
 294
 295 gchar *
 296 sipe_backend_candidate_get_base_ip(struct sipe_backend_candidate *candidate)
 297 {
 298         _NIF();
 299         return FALSE;
 300 }
 301
 302 guint
 303 sipe_backend_candidate_get_base_port(struct sipe_backend_candidate *candidate)
 304 {
 305         _NIF();
 306         return 0;
 307 }
 308
 309 guint32
 310 sipe_backend_candidate_get_priority(struct sipe_backend_candidate *candidate)
 311 {
 312         _NIF();
 313         return 0;
 314 }
 315
 316 void
 317 sipe_backend_candidate_set_priority(struct sipe_backend_candidate *candidate, guint32 priority)
 318 {
 319         _NIF();
 320 }
 321
 322 SipeComponentType
 323 sipe_backend_candidate_get_component_type(struct sipe_backend_candidate *candidate)
 324 {
 325         _NIF();
 326         return SIPE_COMPONENT_NONE;
 327 }
 328
 329 SipeCandidateType
 330 sipe_backend_candidate_get_type(struct sipe_backend_candidate *candidate)
 331 {
 332         _NIF();
 333         return SIPE_CANDIDATE_TYPE_ANY;
 334 }
 335
 336 SipeNetworkProtocol
 337 sipe_backend_candidate_get_protocol(struct sipe_backend_candidate *candidate)
 338 {
 339         _NIF();
 340         return SIPE_NETWORK_PROTOCOL_TCP_ACTIVE;
 341 }
 342
 343 GList *
 344 sipe_backend_get_local_candidates(struct sipe_media_call *media,
 345                                   struct sipe_media_stream *stream)
 346 {
 347         _NIF();
 348         return FALSE;
 349 }
 350
 351 void
 352 sipe_backend_media_accept(struct sipe_backend_media *media, gboolean local)
 353 {
 354         _NIF();
 355 }
 356
 357 void
 358 sipe_backend_media_hangup(struct sipe_backend_media *media, gboolean local)
 359 {
 360         _NIF();
 361 }
 362
 363 void
 364 sipe_backend_media_reject(struct sipe_backend_media *media, gboolean local)
 365 {
 366         _NIF();
 367 }
 368
 369 SipeEncryptionPolicy
 370 sipe_backend_media_get_encryption_policy(struct sipe_core_public *sipe_public)
 371 {
 372         return SIPE_ENCRYPTION_POLICY_REJECTED;
 373 }
 374
 375 gssize
 376 sipe_backend_media_stream_read(struct sipe_media_stream *stream,
 377                                guint8 *buffer, gsize len)
 378 {
 379         _NIF();
 380 }
 381
 382 gssize
 383 sipe_backend_media_stream_write(struct sipe_media_stream *stream,
 384                                 guint8 *buffer, gsize len)
 385 {
 386         _NIF();
 387 }
 388
 389 /*
 390   Local Variables:
 391   mode: c
 392   c-file-style: "bsd"
 393   indent-tabs-mode: t
 394   tab-width: 8
 395   End:
 396 */