src/api/sipe-backend.h

   1 /**
   2  * @file sipe-backend.h
   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 /**
  24  *
  25  * SIPE Core -> Backend API - functions called by SIPE core code
  26  *
  27  ***************** !!! IMPORTANT NOTE FOR BACKEND CODERS !!! *****************
  28  *
  29  *            The SIPE core assumes atomicity and is *NOT* thread-safe.
  30  *
  31  * It *does not* protect any of its data structures or code paths with locks!
  32  *
  33  * In no circumstances it must be possible that a sipe_core_xxx() function can
  34  * be entered through another thread while the first thread has entered the
  35  * backend specific code through a sipe_backend_xxx() function.
  36  *
  37  ***************** !!! IMPORTANT NOTE FOR BACKEND CODERS !!! *****************
  38  */
  39
  40 #ifdef __cplusplus
  41 extern "C" {
  42 #endif
  43
  44 /* Forward declarations */
  45 struct sipe_backend_chat_session;
  46 struct sipe_chat_session;
  47 struct sipe_core_public;
  48 struct sipe_transport_connection;
  49 struct sipe_file_transfer;
  50 struct sipe_media_call;
  51 struct sipe_media;
  52
  53 /** MISC. STUFF **************************************************************/
  54 /**
  55  * Get the version of the backend suitable for e.g. UserAgent
  56  *
  57  * @return backend version string. Will be g_free()'d.by the core.
  58  */
  59 gchar *sipe_backend_version(void);
  60
  61 /** DEBUGGING ****************************************************************/
  62
  63 typedef enum {
  64         SIPE_LOG_LEVEL_INFO,
  65         SIPE_LOG_LEVEL_WARNING,
  66         SIPE_LOG_LEVEL_ERROR,
  67         SIPE_DEBUG_LEVEL_INFO,
  68         SIPE_DEBUG_LEVEL_WARNING,
  69         SIPE_DEBUG_LEVEL_ERROR,
  70 }  sipe_debug_level;
  71 #define SIPE_DEBUG_LEVEL_LOWEST SIPE_DEBUG_LEVEL_INFO
  72
  73 /**
  74  * Output debug information without formatting
  75  *
  76  * Shouldn't be used directly. Instead use SIPE_DEBUG_xxx() macros
  77  *
  78  * @param level  debug level
  79  * @param msg    debug message "\n" will be automatically appended.
  80  */
  81 void sipe_backend_debug_literal(sipe_debug_level level,
  82                                 const gchar *msg);
  83
  84 /**
  85  * Output debug information
  86  *
  87  * Shouldn't be used directly. Instead use SIPE_DEBUG_xxx() macros
  88  *
  89  * @param level  debug level
  90  * @param format format string. "\n" will be automatically appended.
  91  */
  92 void sipe_backend_debug(sipe_debug_level level,
  93                         const gchar *format,
  94                         ...) G_GNUC_PRINTF(2, 3);
  95
  96 /* Convenience macros */
  97 #define SIPE_LOG_INFO(fmt, ...)          sipe_backend_debug(SIPE_LOG_LEVEL_INFO,    fmt, __VA_ARGS__)
  98 #define SIPE_LOG_INFO_NOFORMAT(msg)      sipe_backend_debug_literal(SIPE_LOG_LEVEL_INFO,    msg)
  99 #define SIPE_LOG_WARNING(fmt, ...)       sipe_backend_debug(SIPE_LOG_LEVEL_WARNING, fmt, __VA_ARGS__)
 100 #define SIPE_LOG_WARNING_NOFORMAT(msg)   sipe_backend_debug_literal(SIPE_LOG_LEVEL_WARNING, msg)
 101 #define SIPE_LOG_ERROR(fmt, ...)         sipe_backend_debug(SIPE_LOG_LEVEL_ERROR,   fmt, __VA_ARGS__)
 102 #define SIPE_LOG_ERROR_NOFORMAT(msg)     sipe_backend_debug_literal(SIPE_LOG_LEVEL_ERROR,   msg)
 103 #define SIPE_DEBUG_INFO(fmt, ...)        sipe_backend_debug(SIPE_DEBUG_LEVEL_INFO,    fmt, __VA_ARGS__)
 104 #define SIPE_DEBUG_INFO_NOFORMAT(msg)    sipe_backend_debug_literal(SIPE_DEBUG_LEVEL_INFO,    msg)
 105 #define SIPE_DEBUG_WARNING(fmt, ...)     sipe_backend_debug(SIPE_DEBUG_LEVEL_WARNING, fmt, __VA_ARGS__)
 106 #define SIPE_DEBUG_WARNING_NOFORMAT(msg) sipe_backend_debug_literal(SIPE_DEBUG_LEVEL_WARNING, msg)
 107 #define SIPE_DEBUG_ERROR(fmt, ...)       sipe_backend_debug(SIPE_DEBUG_LEVEL_ERROR,   fmt, __VA_ARGS__)
 108 #define SIPE_DEBUG_ERROR_NOFORMAT(msg)   sipe_backend_debug_literal(SIPE_DEBUG_LEVEL_ERROR,   msg)
 109
 110 /**
 111  * Check backend debugging status
 112  *
 113  * @return TRUE if debugging is enabled
 114  */
 115 gboolean sipe_backend_debug_enabled(void);
 116
 117 /** CHAT *********************************************************************/
 118
 119 void sipe_backend_chat_session_destroy(struct sipe_backend_chat_session *session);
 120 void sipe_backend_chat_add(struct sipe_backend_chat_session *backend_session,
 121                            const gchar *uri,
 122                            gboolean is_new);
 123 void sipe_backend_chat_close(struct sipe_backend_chat_session *backend_session);
 124
 125 /**
 126  * Joined a new chat
 127  */
 128 struct sipe_backend_chat_session *sipe_backend_chat_create(struct sipe_core_public *sipe_public,
 129                                                            struct sipe_chat_session *session,
 130                                                            const gchar *title,
 131                                                            const gchar *nick);
 132 gboolean sipe_backend_chat_find(struct sipe_backend_chat_session *backend_session,
 133                                 const gchar *uri);
 134 gboolean sipe_backend_chat_is_operator(struct sipe_backend_chat_session *backend_session,
 135                                        const gchar *uri);
 136 void sipe_backend_chat_message(struct sipe_core_public *sipe_public,
 137                                struct sipe_backend_chat_session *backend_session,
 138                                const gchar *from,
 139                                time_t when,
 140                                const gchar *html);
 141 void sipe_backend_chat_operator(struct sipe_backend_chat_session *backend_session,
 142                                 const gchar *uri);
 143
 144 /**
 145  * Rejoin an existing chat window after connection re-establishment
 146  */
 147 void sipe_backend_chat_rejoin(struct sipe_core_public *sipe_public,
 148                               struct sipe_backend_chat_session *backend_session,
 149                               const gchar *nick,
 150                               const gchar *title);
 151
 152 /**
 153  * Core has completed connection re-establishment.
 154  * Should call sipe_core_chat_rejoin() for existing chats.
 155  */
 156 void sipe_backend_chat_rejoin_all(struct sipe_core_public *sipe_public);
 157 void sipe_backend_chat_remove(struct sipe_backend_chat_session *backend_session,
 158                               const gchar *uri);
 159
 160 /**
 161  * Move chat window to the front. Will be called when
 162  * a user tries to join an already joined chat again.
 163  */
 164 void sipe_backend_chat_show(struct sipe_backend_chat_session *backend_session);
 165 void sipe_backend_chat_topic(struct sipe_backend_chat_session *backend_session,
 166                              const gchar *topic);
 167
 168 /** CONNECTION ***************************************************************/
 169
 170 void sipe_backend_connection_completed(struct sipe_core_public *sipe_public);
 171
 172 typedef enum {
 173   SIPE_CONNECTION_ERROR_NETWORK = 0,
 174   SIPE_CONNECTION_ERROR_INVALID_USERNAME,
 175   SIPE_CONNECTION_ERROR_INVALID_SETTINGS,
 176   SIPE_CONNECTION_ERROR_AUTHENTICATION_FAILED,
 177   SIPE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE,
 178   SIPE_CONNECTION_ERROR_LAST
 179 } sipe_connection_error;
 180 void sipe_backend_connection_error(struct sipe_core_public *sipe_public,
 181                                    sipe_connection_error error,
 182                                    const gchar *msg);
 183
 184 gboolean sipe_backend_connection_is_disconnecting(struct sipe_core_public *sipe_public);
 185 gboolean sipe_backend_connection_is_valid(struct sipe_core_public *sipe_public);
 186
 187 /** DNS QUERY ****************************************************************/
 188
 189 typedef void (*sipe_dns_resolved_cb)(gpointer data, const gchar *hostname, guint port);
 190
 191 struct sipe_dns_query *sipe_backend_dns_query_srv(struct sipe_core_public *sipe_public,
 192                                                   const gchar *protocol,
 193                                                   const gchar *transport,
 194                                                   const gchar *domain,
 195                                                   sipe_dns_resolved_cb callback,
 196                                                   gpointer data);
 197
 198 struct sipe_dns_query *sipe_backend_dns_query_a(struct sipe_core_public *sipe_public,
 199                                                 const gchar *hostname,
 200                                                 guint port,
 201                                                 sipe_dns_resolved_cb callback,
 202                                                 gpointer data);
 203
 204 void sipe_backend_dns_query_cancel(struct sipe_dns_query *query);
 205
 206 /** FILE TRANSFER ************************************************************/
 207
 208 struct sipe_backend_fd;
 209
 210 void sipe_backend_ft_error(struct sipe_file_transfer *ft,
 211                            const gchar *errmsg);
 212 const gchar *sipe_backend_ft_get_error(struct sipe_file_transfer *ft);
 213 void sipe_backend_ft_deallocate(struct sipe_file_transfer *ft);
 214
 215 /**
 216  * Try to read up to @c size bytes from file transfer connection
 217  *
 218  * @param ft   file transfer data.
 219  * @param data buffer to read data into.
 220  * @param size buffer size in bytes.
 221  *
 222  * @return number of bytes read or negative on failure.
 223  *         EAGAIN should return 0 bytes read.
 224  */
 225 gssize sipe_backend_ft_read(struct sipe_file_transfer *ft,
 226                             guchar *data,
 227                             gsize size);
 228
 229 /**
 230  * Try to write up to @c size bytes to file transfer connection
 231  *
 232  * @param ft   file transfer data.
 233  * @param data data to write
 234  * @param size buffer size in bytes.
 235  *
 236  * @return number of bytes read or negative on failure.
 237  *         EAGAIN should return 0 bytes written.
 238  */
 239 gssize sipe_backend_ft_write(struct sipe_file_transfer *ft,
 240                              const guchar *data,
 241                              gsize size);
 242
 243 void sipe_backend_ft_set_completed(struct sipe_file_transfer *ft);
 244
 245 void sipe_backend_ft_cancel_local(struct sipe_file_transfer *ft);
 246 void sipe_backend_ft_cancel_remote(struct sipe_file_transfer *ft);
 247
 248 void sipe_backend_ft_incoming(struct sipe_core_public *sipe_public,
 249                               struct sipe_file_transfer *ft,
 250                               const gchar *who,
 251                               const gchar *file_name,
 252                               gsize file_size);
 253 /**
 254  * Allocates and initializes backend file transfer structure for sending a file.
 255  *
 256  * @param sipe_public (in) the handle representing the protocol instance
 257  * @param ft (in) sipe core file transfer structure
 258  * @param who (in) SIP URI of the file recipient
 259  * @param file_name (in) filesystem path of the file being sent
 260  */
 261 void sipe_backend_ft_outgoing(struct sipe_core_public *sipe_public,
 262                               struct sipe_file_transfer *ft,
 263                               const gchar *who,
 264                               const gchar *file_name);
 265 /**
 266  * Begins file transfer with remote peer.
 267  *
 268  * You can provide either opened file descriptor to use for read/write operations
 269  * or ip address and port where the backend should connect.
 270  *
 271  * @param ft   file transfer data
 272  * @param fd   opaque file descriptor pointer or NULL if ip and port are used
 273  * @param ip   ip address to connect of NULL when file descriptor is used
 274  * @param port port to connect or 0 when file descriptor is used
 275  */
 276 void sipe_backend_ft_start(struct sipe_file_transfer *ft,
 277                            struct sipe_backend_fd *fd,
 278                            const char* ip, unsigned port);
 279
 280 /**
 281  * Check whether file transfer is incoming or outgoing
 282  *
 283  * @param ft file transfer data
 284  * @return @c TRUE if @c ft is incoming, otherwise @c FALSE
 285  */
 286 gboolean sipe_backend_ft_is_incoming(struct sipe_file_transfer *ft);
 287
 288 /** GROUP CHAT ***************************************************************/
 289
 290 #define SIPE_GROUPCHAT_ROOM_FILEPOST 0x00000001
 291 #define SIPE_GROUPCHAT_ROOM_INVITE   0x00000002
 292 #define SIPE_GROUPCHAT_ROOM_LOGGED   0x00000004
 293 #define SIPE_GROUPCHAT_ROOM_PRIVATE  0x00000008
 294
 295 /**
 296  * Add a room found through room query
 297  *
 298  * @param uri         room URI
 299  * @param name        human readable name for room
 300  * @param description room description
 301  * @param users       number of users in the room
 302  * @param flags       SIPE_GROUPCHAT_ROOM_* flags
 303  */
 304 void sipe_backend_groupchat_room_add(struct sipe_core_public *sipe_public,
 305                                      const gchar *uri,
 306                                      const gchar *name,
 307                                      const gchar *description,
 308                                      guint users,
 309                                      guint32 flags);
 310
 311 /**
 312  * Terminate room query
 313  */
 314 void sipe_backend_groupchat_room_terminate(struct sipe_core_public *sipe_public);
 315
 316 /** IM ***********************************************************************/
 317
 318 void sipe_backend_im_message(struct sipe_core_public *sipe_public,
 319                              const gchar *from,
 320                              const gchar *html);
 321 void sipe_backend_im_topic(struct sipe_core_public *sipe_public,
 322                            const gchar *with,
 323                            const gchar *topic);
 324
 325 /** MARKUP *******************************************************************/
 326
 327 gchar *sipe_backend_markup_css_property(const gchar *style,
 328                                         const gchar *option);
 329 gchar *sipe_backend_markup_strip_html(const gchar *html);
 330
 331 /** MEDIA ********************************************************************/
 332
 333 typedef enum {
 334         /* This client is the one who invites other participant to the call. */
 335         SIPE_MEDIA_CALL_INITIATOR = 1,
 336         /* Don't show any user interface elements for the call. */
 337         SIPE_MEDIA_CALL_NO_UI = 2
 338 } SipeMediaCallFlags;
 339
 340 typedef enum {
 341         SIPE_ICE_NO_ICE,
 342         SIPE_ICE_DRAFT_6,
 343         SIPE_ICE_RFC_5245
 344 } SipeIceVersion;
 345
 346 typedef enum {
 347         SIPE_CANDIDATE_TYPE_ANY,
 348         SIPE_CANDIDATE_TYPE_HOST,
 349         SIPE_CANDIDATE_TYPE_RELAY,
 350         SIPE_CANDIDATE_TYPE_SRFLX,
 351         SIPE_CANDIDATE_TYPE_PRFLX
 352 } SipeCandidateType;
 353
 354 typedef enum {
 355         SIPE_COMPONENT_NONE = 0,
 356         SIPE_COMPONENT_RTP  = 1,
 357         SIPE_COMPONENT_RTCP = 2
 358 } SipeComponentType;
 359
 360 typedef enum {
 361         SIPE_MEDIA_AUDIO,
 362         SIPE_MEDIA_VIDEO,
 363         SIPE_MEDIA_APPLICATION
 364 } SipeMediaType;
 365
 366 typedef enum {
 367         SIPE_NETWORK_PROTOCOL_UDP,
 368         SIPE_NETWORK_PROTOCOL_TCP_ACTIVE,
 369         SIPE_NETWORK_PROTOCOL_TCP_PASSIVE,
 370         SIPE_NETWORK_PROTOCOL_TCP_SO,
 371 } SipeNetworkProtocol;
 372
 373 typedef enum {
 374         SIPE_ENCRYPTION_POLICY_REJECTED,
 375         SIPE_ENCRYPTION_POLICY_OPTIONAL,
 376         SIPE_ENCRYPTION_POLICY_REQUIRED,
 377         SIPE_ENCRYPTION_POLICY_OBEY_SERVER
 378 } SipeEncryptionPolicy;
 379
 380 struct sipe_media_call;
 381 struct sipe_backend_media;
 382 struct sipe_backend_codec;
 383 struct sipe_backend_candidate;
 384 struct sipe_backend_media_stream;
 385 struct sipe_backend_media_relays;
 386
 387 struct ssrc_range {
 388         guint32 begin;
 389         guint32 end;
 390 };
 391
 392 struct sipe_media_stream {
 393         struct sipe_backend_media_stream *backend_private;
 394
 395         struct sipe_media_call *call;
 396         gchar *id;
 397         struct ssrc_range *ssrc_range;
 398
 399         void (*candidate_pairs_established_cb)(struct sipe_media_stream *);
 400         void (*read_cb)(struct sipe_media_stream *);
 401         void (*writable_cb)(struct sipe_media_stream *);
 402         void (*mute_cb)(struct sipe_media_stream *, gboolean is_muted);
 403 };
 404
 405 struct sipe_media_call {
 406         struct sipe_backend_media *backend_private;
 407
 408         gchar *with;
 409
 410         void (*stream_initialized_cb)(struct sipe_media_call *,
 411                                       struct sipe_media_stream *);
 412         void (*media_end_cb)(struct sipe_media_call *);
 413         void (*call_accept_cb)(struct sipe_media_call *, gboolean local);
 414         void (*call_reject_cb)(struct sipe_media_call *, gboolean local);
 415         void (*call_hold_cb)  (struct sipe_media_call *, gboolean local,
 416                                gboolean state);
 417         void (*call_hangup_cb)(struct sipe_media_call *, gboolean local);
 418         void (*error_cb)(struct sipe_media_call *, gchar *message);
 419 };
 420
 421 struct sipe_media_relay {
 422         gchar                 *hostname;
 423         guint                  udp_port;
 424         guint                  tcp_port;
 425         struct sipe_dns_query *dns_query;
 426 };
 427
 428 /* Media handling */
 429 struct sipe_backend_media *sipe_backend_media_new(struct sipe_core_public *sipe_public,
 430                                                   struct sipe_media_call *call,
 431                                                   const gchar *participant,
 432                                                   SipeMediaCallFlags flags);
 433 void sipe_backend_media_free(struct sipe_backend_media *media);
 434
 435 void sipe_backend_media_set_cname(struct sipe_backend_media *media, gchar *cname);
 436
 437 struct sipe_backend_media_relays * sipe_backend_media_relays_convert(GSList *media_relays,
 438                                                                      gchar *username,
 439                                                                      gchar *password);
 440 void sipe_backend_media_relays_free(struct sipe_backend_media_relays *media_relays);
 441
 442 struct sipe_backend_media_stream *sipe_backend_media_add_stream(struct sipe_media_stream *stream,
 443                                                           SipeMediaType type,
 444                                                           SipeIceVersion ice_version,
 445                                                           gboolean initiator,
 446                                                           struct sipe_backend_media_relays *media_relays,
 447                                                           guint min_port, guint max_port);
 448 void sipe_backend_media_add_remote_candidates(struct sipe_media_call *media,
 449                                               struct sipe_media_stream *stream,
 450                                               GList *candidates);
 451 gboolean sipe_backend_media_is_initiator(struct sipe_media_call *media,
 452                                          struct sipe_media_stream *stream);
 453 gboolean sipe_backend_media_accepted(struct sipe_backend_media *media);
 454 gboolean sipe_backend_stream_initialized(struct sipe_media_call *media,
 455                                          struct sipe_media_stream *stream);
 456 void sipe_backend_media_set_encryption_keys(struct sipe_media_call *media,
 457                                             struct sipe_media_stream *stream,
 458                                             const guchar *encryption_key,
 459                                             const guchar *decryption_key);
 460
 461 /* Stream handling */
 462 void sipe_backend_stream_hold(struct sipe_media_call *media,
 463                               struct sipe_media_stream *stream,
 464                               gboolean local);
 465 void sipe_backend_stream_unhold(struct sipe_media_call *media,
 466                                 struct sipe_media_stream *stream,
 467                                 gboolean local);
 468 gboolean sipe_backend_stream_is_held(struct sipe_media_stream *stream);
 469
 470 GList *sipe_backend_media_stream_get_active_local_candidates(struct sipe_media_stream *stream);
 471 GList *sipe_backend_media_stream_get_active_remote_candidates(struct sipe_media_stream *stream);
 472
 473 gssize sipe_backend_media_stream_read(struct sipe_media_stream *stream,
 474                                      guint8 *buffer, gsize len);
 475 gssize sipe_backend_media_stream_write(struct sipe_media_stream *stream,
 476                                        guint8 *buffer, gsize len);
 477
 478 void sipe_backend_media_stream_end(struct sipe_media_call *media,
 479                                    struct sipe_media_stream *stream);
 480 void sipe_backend_media_stream_free(struct sipe_backend_media_stream *stream);
 481
 482 /* Codec handling */
 483 struct sipe_backend_codec *sipe_backend_codec_new(int id,
 484                                                   const char *name,
 485                                                   SipeMediaType type,
 486                                                   guint clock_rate,
 487                                                   guint channels);
 488 void sipe_backend_codec_free(struct sipe_backend_codec *codec);
 489 int sipe_backend_codec_get_id(struct sipe_backend_codec *codec);
 490 /**
 491  * @return codec name. Will be g_free'd() by the core.
 492  */
 493 gchar *sipe_backend_codec_get_name(struct sipe_backend_codec *codec);
 494 guint sipe_backend_codec_get_clock_rate(struct sipe_backend_codec *codec);
 495 void sipe_backend_codec_add_optional_parameter(struct sipe_backend_codec *codec,
 496                                                const gchar *name,
 497                                                const gchar *value);
 498 GList *sipe_backend_codec_get_optional_parameters(struct sipe_backend_codec *codec);
 499 gboolean sipe_backend_set_remote_codecs(struct sipe_media_call *media,
 500                                         struct sipe_media_stream *stream,
 501                                         GList *codecs);
 502 GList* sipe_backend_get_local_codecs(struct sipe_media_call *media,
 503                                      struct sipe_media_stream *stream);
 504
 505 /* Candidate handling */
 506 struct sipe_backend_candidate * sipe_backend_candidate_new(const gchar *foundation,
 507                                                            SipeComponentType component,
 508                                                            SipeCandidateType type,
 509                                                            SipeNetworkProtocol proto,
 510                                                            const gchar *ip, guint port,
 511                                                            const gchar *username,
 512                                                            const gchar *password);
 513 void sipe_backend_candidate_free(struct sipe_backend_candidate *candidate);
 514 /**
 515  * @return user name. Will be g_free'd() by the core.
 516  */
 517 gchar *sipe_backend_candidate_get_username(struct sipe_backend_candidate *candidate);
 518 /**
 519  * @return password. Will be g_free'd() by the core.
 520  */
 521 gchar *sipe_backend_candidate_get_password(struct sipe_backend_candidate *candidate);
 522 /**
 523  * @return foundation. Will be g_free'd() by the core.
 524  */
 525 gchar *sipe_backend_candidate_get_foundation(struct sipe_backend_candidate *candidate);
 526 /**
 527  * @return IP address string. Will be g_free'd() by the core.
 528  */
 529 gchar *sipe_backend_candidate_get_ip(struct sipe_backend_candidate *candidate);
 530 guint sipe_backend_candidate_get_port(struct sipe_backend_candidate *candidate);
 531 /**
 532  * @return IP address string. Will be g_free'd() by the core.
 533  */
 534 gchar *sipe_backend_candidate_get_base_ip(struct sipe_backend_candidate *candidate);
 535 guint sipe_backend_candidate_get_base_port(struct sipe_backend_candidate *candidate);
 536 guint32 sipe_backend_candidate_get_priority(struct sipe_backend_candidate *candidate);
 537 void sipe_backend_candidate_set_priority(struct sipe_backend_candidate *candidate, guint32 priority);
 538 SipeComponentType sipe_backend_candidate_get_component_type(struct sipe_backend_candidate *candidate);
 539 SipeCandidateType sipe_backend_candidate_get_type(struct sipe_backend_candidate *candidate);
 540 SipeNetworkProtocol sipe_backend_candidate_get_protocol(struct sipe_backend_candidate *candidate);
 541 GList* sipe_backend_get_local_candidates(struct sipe_media_call *media,
 542                                          struct sipe_media_stream *stream);
 543 void sipe_backend_media_accept(struct sipe_backend_media *media, gboolean local);
 544 void sipe_backend_media_hangup(struct sipe_backend_media *media, gboolean local);
 545 void sipe_backend_media_reject(struct sipe_backend_media *media, gboolean local);
 546
 547 /** NETWORK ******************************************************************/
 548
 549 struct sipe_backend_listendata;
 550
 551 typedef void (*sipe_listen_start_cb)(unsigned short port, gpointer data);
 552 typedef void (*sipe_client_connected_cb)(struct sipe_backend_fd *fd, gpointer data);
 553
 554 struct sipe_backend_listendata *
 555 sipe_backend_network_listen_range(unsigned short port_min,
 556                                   unsigned short port_max,
 557                                   sipe_listen_start_cb listen_cb,
 558                                   sipe_client_connected_cb connect_cb,
 559                                   gpointer data);
 560 void sipe_backend_network_listen_cancel(struct sipe_backend_listendata *ldata);
 561
 562 struct sipe_backend_fd * sipe_backend_fd_from_int(int fd);
 563 gboolean sipe_backend_fd_is_valid(struct sipe_backend_fd *fd);
 564 void sipe_backend_fd_free(struct sipe_backend_fd *fd);
 565
 566 /** NOTIFICATIONS *************************************************************/
 567
 568 void sipe_backend_notify_message_error(struct sipe_core_public *sipe_public,
 569                                        struct sipe_backend_chat_session *backend_session,
 570                                        const gchar *who,
 571                                        const gchar *message);
 572 void sipe_backend_notify_message_info(struct sipe_core_public *sipe_public,
 573                                       struct sipe_backend_chat_session *backend_session,
 574                                       const gchar *who,
 575                                       const gchar *message);
 576
 577 /**
 578  * @param msg  error message. Maybe @NULL
 579  */
 580 void sipe_backend_notify_error(struct sipe_core_public *sipe_public,
 581                                const gchar *title,
 582                                const gchar *msg);
 583
 584 /** SCHEDULE *****************************************************************/
 585
 586 gpointer sipe_backend_schedule_seconds(struct sipe_core_public *sipe_public,
 587                                        guint timeout,
 588                                        gpointer data);
 589 gpointer sipe_backend_schedule_mseconds(struct sipe_core_public *sipe_public,
 590                                         guint timeout,
 591                                         gpointer data);
 592 void sipe_backend_schedule_cancel(struct sipe_core_public *sipe_public,
 593                                   gpointer data);
 594
 595 /** SEARCH *******************************************************************/
 596
 597 struct sipe_backend_search_results;
 598 struct sipe_backend_search_token;
 599
 600 void sipe_backend_search_failed(struct sipe_core_public *sipe_public,
 601                                 struct sipe_backend_search_token *token,
 602                                 const gchar *msg);
 603 struct sipe_backend_search_results *sipe_backend_search_results_start(struct sipe_core_public *sipe_public,
 604                                                                       struct sipe_backend_search_token *token);
 605 void sipe_backend_search_results_add(struct sipe_core_public *sipe_public,
 606                                      struct sipe_backend_search_results *results,
 607                                      const gchar *uri,
 608                                      const gchar *name,
 609                                      const gchar *company,
 610                                      const gchar *country,
 611                                      const gchar *email);
 612 void sipe_backend_search_results_finalize(struct sipe_core_public *sipe_public,
 613                                           struct sipe_backend_search_results *results,
 614                                           const gchar *description,
 615                                           gboolean more);
 616
 617 /** SETTINGS *****************************************************************/
 618
 619 typedef enum {
 620   SIPE_SETTING_EMAIL_URL = 0,
 621   SIPE_SETTING_EMAIL_LOGIN,
 622   SIPE_SETTING_EMAIL_PASSWORD,
 623   SIPE_SETTING_GROUPCHAT_USER,
 624   SIPE_SETTING_RDP_CLIENT,
 625   SIPE_SETTING_USER_AGENT,
 626   SIPE_SETTING_LAST
 627 } sipe_setting;
 628 const gchar *sipe_backend_setting(struct sipe_core_public *sipe_public,
 629                                   sipe_setting type);
 630
 631 /** STATUS *******************************************************************/
 632
 633 guint sipe_backend_status(struct sipe_core_public *sipe_public);
 634 gboolean sipe_backend_status_changed(struct sipe_core_public *sipe_public,
 635                                      guint activity,
 636                                      const gchar *message);
 637
 638 /**
 639  * Update user client with new status and note received from server
 640  *
 641  * NOTE: this must *NOT* trigger a call to @c sipe_core_status_set()!
 642  *
 643  * @param sipe_public   The handle representing the protocol instance
 644  * @param activity      New activity
 645  * @param message       New note text
 646  */
 647 void sipe_backend_status_and_note(struct sipe_core_public *sipe_public,
 648                                   guint activity,
 649                                   const gchar *message);
 650
 651 /** TRANSPORT ****************************************************************/
 652
 653 typedef void transport_connected_cb(struct sipe_transport_connection *conn);
 654 typedef void transport_input_cb(struct sipe_transport_connection *conn);
 655 typedef void transport_error_cb(struct sipe_transport_connection *conn,
 656                                 const gchar *msg);
 657
 658 typedef struct {
 659         guint type;
 660         const gchar *server_name;
 661         guint server_port;
 662         gpointer user_data;
 663         transport_connected_cb *connected;
 664         transport_input_cb *input;
 665         transport_error_cb *error;
 666 } sipe_connect_setup;
 667 struct sipe_transport_connection *sipe_backend_transport_connect(struct sipe_core_public *sipe_public,
 668                                                                  const sipe_connect_setup *setup);
 669 void sipe_backend_transport_disconnect(struct sipe_transport_connection *conn);
 670 gchar *sipe_backend_transport_ip_address(struct sipe_transport_connection *conn);
 671 void sipe_backend_transport_message(struct sipe_transport_connection *conn,
 672                                     const gchar *buffer);
 673 void sipe_backend_transport_flush(struct sipe_transport_connection *conn);
 674
 675 /** USER *********************************************************************/
 676
 677 void sipe_backend_user_feedback_typing(struct sipe_core_public *sipe_public,
 678                                        const gchar *from);
 679 void sipe_backend_user_feedback_typing_stop(struct sipe_core_public *sipe_public,
 680                                             const gchar *from);
 681
 682 /**
 683  * Present a query that is to be accepted or declined by the user
 684  *
 685  * @param sipe_public   The handle representing the protocol instance
 686  * @param message       Text of the query to be shown to user
 687  * @param accept_label  Label to be displayed on UI control that accepts query
 688  * @param decline_label Label to be displayed on UI control that declines query
 689  * @param key           Opaque handle uniquely identifying the query. Backend
 690  *                      should store it for the case SIPE core requests the
 691  *                      query to be closed prematurely.
 692  */
 693 void sipe_backend_user_ask(struct sipe_core_public *sipe_public,
 694                            const gchar *message,
 695                            const gchar *accept_label,
 696                            const gchar *decline_label,
 697                            gpointer key);
 698
 699 /**
 700  * Closes the pending user query
 701  *
 702  * @param key Opaque handle uniquely identifying the query.
 703  */
 704 void sipe_backend_user_close_ask(gpointer key);
 705
 706 /** BUDDIES ******************************************************************/
 707
 708 /*
 709  * sipe_backend_buddy_get/set_string(): properties a buddy can have
 710  * sipe_backend_buddy_info_add():       mapped, e.g. to a string label
 711  */
 712 typedef enum
 713 {
 714         SIPE_BUDDY_INFO_DISPLAY_NAME = 0,
 715         SIPE_BUDDY_INFO_JOB_TITLE,
 716         SIPE_BUDDY_INFO_CITY,
 717         SIPE_BUDDY_INFO_STATE,
 718         SIPE_BUDDY_INFO_OFFICE,
 719         SIPE_BUDDY_INFO_DEPARTMENT,
 720         SIPE_BUDDY_INFO_COUNTRY,
 721         SIPE_BUDDY_INFO_WORK_PHONE,
 722         SIPE_BUDDY_INFO_WORK_PHONE_DISPLAY,
 723         SIPE_BUDDY_INFO_COMPANY,
 724         SIPE_BUDDY_INFO_EMAIL,
 725         SIPE_BUDDY_INFO_SITE,
 726         SIPE_BUDDY_INFO_ZIPCODE,
 727         SIPE_BUDDY_INFO_STREET,
 728         SIPE_BUDDY_INFO_MOBILE_PHONE,
 729         SIPE_BUDDY_INFO_MOBILE_PHONE_DISPLAY,
 730         SIPE_BUDDY_INFO_HOME_PHONE,
 731         SIPE_BUDDY_INFO_HOME_PHONE_DISPLAY,
 732         SIPE_BUDDY_INFO_OTHER_PHONE,
 733         SIPE_BUDDY_INFO_OTHER_PHONE_DISPLAY,
 734         SIPE_BUDDY_INFO_CUSTOM1_PHONE,
 735         SIPE_BUDDY_INFO_CUSTOM1_PHONE_DISPLAY,
 736         SIPE_BUDDY_INFO_ALIAS,  /* only for sipe_backend_buddy_info_add() */
 737         SIPE_BUDDY_INFO_DEVICE, /* only for sipe_backend_buddy_info_add() */
 738 } sipe_buddy_info_fields;
 739
 740 /* Opaque token */
 741 typedef void* sipe_backend_buddy;
 742
 743 /**
 744  * Find a buddy in the given group of the buddy list, or anywhere on the
 745  * list if @group_name is empty
 746  *
 747  * @param sipe_public The handle representing the protocol instance making the call
 748  * @param buddy_name The name of the buddy
 749  * @param group_name The name of the group to look in, or NULL for any group
 750  * @return opaque handle to the buddy, or NULL if no buddy found
 751  */
 752 sipe_backend_buddy sipe_backend_buddy_find(struct sipe_core_public *sipe_public,
 753                                            const gchar *buddy_name,
 754                                            const gchar *group_name);
 755
 756 /*
 757  * Find all named buddies in the given group of the buddy list, or anywhere on the
 758  * list if @group_name is empty; or all buddies if @name is empty
 759  *
 760  * @param sipe_public The handle representing the protocol instance making the call
 761  * @param name The name of the buddy
 762  * @param group_name The name of the group to look in, or NULL for any group
 763  * @return GSList of opaque handles to the buddies
 764  */
 765 GSList* sipe_backend_buddy_find_all(struct sipe_core_public *sipe_public,
 766                                     const gchar *buddy_name,
 767                                     const gchar *group_name);
 768
 769 /**
 770  * Gets the name of a contact.
 771  *
 772  * @param sipe_public The handle representing the protocol instance making the call
 773  * @param who The opaque handle to the contact as found by find_buddy
 774  * @return The name. Must be freed.
 775  */
 776 gchar* sipe_backend_buddy_get_name(struct sipe_core_public *sipe_public,
 777                                    const sipe_backend_buddy who);
 778
 779 /**
 780  * Gets the alias for a contact.
 781  *
 782  * @param sipe_public The handle representing the protocol instance making the call
 783  * @param who The opaque handle to the contact as found by find_buddy
 784  * @return The alias. Must be gfree'd.
 785  */
 786 gchar* sipe_backend_buddy_get_alias(struct sipe_core_public *sipe_public,
 787                                     const sipe_backend_buddy who);
 788
 789 /**
 790  * Gets the server alias for a contact.
 791  *
 792  * @param sipe_public The handle representing the protocol instance making the call
 793  * @param who The opaque handle to the contact as found by find_buddy
 794  * @return The alias. Must be freed.
 795  */
 796 gchar* sipe_backend_buddy_get_server_alias(struct sipe_core_public *sipe_public,
 797                                            const sipe_backend_buddy who);
 798
 799 /**
 800  * Gets the local alias for a contact
 801  *
 802  * @param sipe_public The handle representing the protocol instance making the call
 803  * @param uri         the budyy name
 804  *
 805  * @return the alias. Must be @g_free()'d.
 806  */
 807 gchar *sipe_backend_buddy_get_local_alias(struct sipe_core_public *sipe_public,
 808                                           const sipe_backend_buddy who);
 809
 810 /**
 811  * Gets the name of the group a contact belongs to.
 812  *
 813  * @param sipe_public The handle representing the protocol instance making the call
 814  * @param who The opaque handle to the contact as found by find_buddy
 815  * @return The name. Must be freed.
 816  */
 817 gchar* sipe_backend_buddy_get_group_name(struct sipe_core_public *sipe_public,
 818                                          const sipe_backend_buddy who);
 819
 820 /**
 821  * Called to retrieve a buddy-specific setting.
 822  *
 823  * @param sipe_public The handle representing the protocol instance making the call
 824  * @param buddy The handle representing the buddy
 825  * @param key The name of the setting
 826  * @return The value of the setting. Must be freed.
 827  */
 828 gchar* sipe_backend_buddy_get_string(struct sipe_core_public *sipe_public,
 829                                      sipe_backend_buddy buddy,
 830                                      const sipe_buddy_info_fields key);
 831
 832 /**
 833  * Called to set a buddy-specific setting.
 834  *
 835  * @param sipe_public The handle representing the protocol instance making the call
 836  * @param buddy The handle representing the buddy
 837  * @param key The name of the setting
 838  * @param val The value to set
 839  */
 840 void sipe_backend_buddy_set_string(struct sipe_core_public *sipe_public,
 841                                    sipe_backend_buddy buddy,
 842                                    const sipe_buddy_info_fields key,
 843                                    const gchar *val);
 844
 845 /**
 846  * Called after one ore more buddy-specific settings have been updated.
 847  *
 848  * Can be used by the backend to trigger an UI update event
 849  *
 850  * @param sipe_public The handle representing the protocol instance making the call
 851  * @param uri         SIP URI of the contact
 852  */
 853 void sipe_backend_buddy_refresh_properties(struct sipe_core_public *sipe_public,
 854                                            const gchar *uri);
 855
 856 /**
 857  * Get the status token for a contact
 858  *
 859  * @param sipe_public The handle representing the protocol instance making the call
 860  * @param uri         SIP URI of the contact
 861  *
 862  * @return activity
 863  */
 864 guint sipe_backend_buddy_get_status(struct sipe_core_public *sipe_public,
 865                                     const gchar *uri);
 866
 867 /**
 868  * Sets the alias for a contact.
 869  *
 870  * @param sipe_public The handle representing the protocol instance making the call
 871  * @param who The opaque handle to the contact as found by find_buddy
 872  * @param alias The location where the alias will be put
 873  * case. FALSE if the buddy was not found. The value of alias will not be changed.
 874  */
 875 void sipe_backend_buddy_set_alias(struct sipe_core_public *sipe_public,
 876                                   const sipe_backend_buddy who,
 877                                   const gchar *alias);
 878
 879 /**
 880  * Sets the server alias for a contact.
 881  *
 882  * @param sipe_public The handle representing the protocol instance making the call
 883  * @param who The opaque handle to the contact as found by find_buddy
 884  * @param alias The server alias of the contact
 885  */
 886 void sipe_backend_buddy_set_server_alias(struct sipe_core_public *sipe_public,
 887                                          const sipe_backend_buddy who,
 888                                          const gchar *alias);
 889
 890 /**
 891  * Start processing buddy list
 892  *
 893  * Will be called every time we receive a buddy list in roaming contacts
 894  *
 895  * @param sipe_public The handle representing the protocol instance making the call
 896  */
 897 void sipe_backend_buddy_list_processing_start(struct sipe_core_public *sipe_public);
 898
 899 /**
 900  * Finished processing buddy list
 901  *
 902  * Will be called every time we receive a buddy list in roaming contacts
 903  *
 904  * @param sipe_public The handle representing the protocol instance making the call
 905  */
 906 void sipe_backend_buddy_list_processing_finish(struct sipe_core_public *sipe_public);
 907
 908 /**
 909  * Add a contact to the buddy list
 910  *
 911  * @param sipe_public The handle representing the protocol instance making the call
 912  * @param name The name of the contact
 913  * @param alias The alias of the contact
 914  * @param groupname The name of the group to add this contact to
 915  * @return A handle to the newly created buddy
 916  */
 917 sipe_backend_buddy sipe_backend_buddy_add(struct sipe_core_public *sipe_public,
 918                                           const gchar *name,
 919                                           const gchar *alias,
 920                                           const gchar *groupname);
 921
 922 /**
 923  * Remove a contact from the buddy list
 924  *
 925  * @param sipe_public The handle representing the protocol instance making the call
 926  * @param who The opaque handle to the contact as found by find_buddy
 927  */
 928 void sipe_backend_buddy_remove(struct sipe_core_public *sipe_public,
 929                                const sipe_backend_buddy who);
 930
 931 /**
 932  * Notifies the user that a remote user has wants to add the local user to his
 933  * or her buddy list and requires authorization to do so.
 934  *
 935  * @param sipe_public The handle representing the protocol instance making the call
 936  * @param who The name of the user that added this account
 937  * @param alias The optional alias of the remote user
 938  * @param on_list True if the user is already in our list
 939  * @param auth_cb The callback called when the local user accepts
 940  * @param deny_cb The callback called when the local user rejects
 941  * @param data Data to be passed back to the above callbacks
 942  */
 943 typedef void (*sipe_backend_buddy_request_authorization_cb)(void *);
 944
 945 void sipe_backend_buddy_request_add(struct sipe_core_public *sipe_public,
 946                                     const gchar *who,
 947                                     const gchar *alias);
 948
 949 void sipe_backend_buddy_request_authorization(struct sipe_core_public *sipe_public,
 950                                               const gchar *who,
 951                                               const gchar *alias,
 952                                               gboolean on_list,
 953                                               sipe_backend_buddy_request_authorization_cb auth_cb,
 954                                               sipe_backend_buddy_request_authorization_cb deny_cb,
 955                                               gpointer data);
 956
 957 gboolean sipe_backend_buddy_is_blocked(struct sipe_core_public *sipe_public,
 958                                        const gchar *who);
 959
 960 void sipe_backend_buddy_set_blocked_status(struct sipe_core_public *sipe_public,
 961                                            const gchar *who,
 962                                            gboolean blocked);
 963
 964 void sipe_backend_buddy_set_status(struct sipe_core_public *sipe_public,
 965                                    const gchar *who,
 966                                    guint activity);
 967
 968 /**
 969  * Checks whether backend has a capability to use buddy photos. If this function
 970  * returns @c FALSE, SIPE core will not attempt to download the photos from
 971  * server to save bandwidth.
 972  *
 973  * @return @c TRUE if backend is photo capable, otherwise @FALSE
 974  */
 975 gboolean sipe_backend_uses_photo(void);
 976
 977 /**
 978  * Gives backend a photo image associated with a SIP URI. Backend has ownership
 979  * of the data and must free it when not needed.
 980  *
 981  * @param sipe_public The handle representing the protocol instance making the call
 982  * @param who The name of the user whose photo is being set
 983  * @param image_data The photo image data, must be g_free()'d by backend
 984  * @param image_len Size of the image in Bytes
 985  * @param photo_hash A data checksum provided by the server
 986  */
 987 void sipe_backend_buddy_set_photo(struct sipe_core_public *sipe_public,
 988                                   const gchar *who,
 989                                   gpointer image_data,
 990                                   gsize image_len,
 991                                   const gchar *photo_hash);
 992
 993 /**
 994  * Retrieves a photo hash stored together with image data by
 995  * @c sipe_backend_buddy_set_photo. Value is used by the core to detect photo
 996  * file changes on server.
 997  *
 998  * @param sipe_public The handle representing the protocol instance making the call
 999  * @param who The name of the user whose photo hash to retrieve
1000  * @return a photo hash (may be NULL)
1001  */
1002 const gchar *sipe_backend_buddy_get_photo_hash(struct sipe_core_public *sipe_public,
1003                                                const gchar *who);
1004
1005 /**
1006  * Called when a new internal group is about to be added. If this returns FALSE,
1007  * the group will not be added.
1008  *
1009  * @param sipe_public The handle representing the protocol instance making the call
1010  * @param group_name  The group being added
1011  * @return TRUE if everything is ok, FALSE if the group should not be added
1012  */
1013 gboolean sipe_backend_buddy_group_add(struct sipe_core_public *sipe_public,
1014                                       const gchar *group_name);
1015
1016 /**
1017  * Called when a new internal group has been renamed
1018  *
1019  * @param sipe_public The handle representing the protocol instance making the call
1020  * @param old_name old name of the group
1021  * @param new_name new name of the group
1022  * @return TRUE if the group was found and renamed
1023  */
1024 gboolean sipe_backend_buddy_group_rename(struct sipe_core_public *sipe_public,
1025                                          const gchar *old_name,
1026                                          const gchar *new_name);
1027
1028 /**
1029  * Called when a new internal group should be deleted
1030  *
1031  * NOTE: this will only be called on empty groups.
1032  *
1033  * @param sipe_public The handle representing the protocol instance making the call
1034  * @param group_name  The group that should be removed
1035  */
1036 void sipe_backend_buddy_group_remove(struct sipe_core_public *sipe_public,
1037                                      const gchar *group_name);
1038
1039 /**
1040  * Present requested buddy information to the user
1041  */
1042 struct sipe_backend_buddy_info;
1043 struct sipe_backend_buddy_info *sipe_backend_buddy_info_start(struct sipe_core_public *sipe_public);
1044 void sipe_backend_buddy_info_add(struct sipe_core_public *sipe_public,
1045                                  struct sipe_backend_buddy_info *info,
1046                                  sipe_buddy_info_fields key,
1047                                  const gchar *value);
1048 void sipe_backend_buddy_info_break(struct sipe_core_public *sipe_public,
1049                                    struct sipe_backend_buddy_info *info);
1050 void sipe_backend_buddy_info_finalize(struct sipe_core_public *sipe_public,
1051                                       struct sipe_backend_buddy_info *info,
1052                                       const gchar *uri);
1053
1054 struct sipe_backend_buddy_tooltip;
1055 void sipe_backend_buddy_tooltip_add(struct sipe_core_public *sipe_public,
1056                                     struct sipe_backend_buddy_tooltip *tooltip,
1057                                     const gchar *description,
1058                                     const gchar *value);
1059
1060 /**
1061  * Buddy menu creation
1062  */
1063 enum sipe_buddy_menu_type {
1064         SIPE_BUDDY_MENU_MAKE_CHAT_LEADER = 0,
1065         SIPE_BUDDY_MENU_REMOVE_FROM_CHAT,
1066         SIPE_BUDDY_MENU_INVITE_TO_CHAT,
1067         SIPE_BUDDY_MENU_NEW_CHAT,
1068         SIPE_BUDDY_MENU_MAKE_CALL,
1069         SIPE_BUDDY_MENU_SEND_EMAIL,
1070         SIPE_BUDDY_MENU_ACCESS_LEVEL_HELP,
1071         SIPE_BUDDY_MENU_CHANGE_ACCESS_LEVEL,
1072         SIPE_BUDDY_MENU_ADD_NEW_DOMAIN,
1073         SIPE_BUDDY_MENU_TYPES
1074 };
1075
1076 struct sipe_backend_buddy_menu *sipe_backend_buddy_menu_start(struct sipe_core_public *sipe_public);
1077 struct sipe_backend_buddy_menu *sipe_backend_buddy_menu_add(struct sipe_core_public *sipe_public,
1078                                                             struct sipe_backend_buddy_menu *menu,
1079                                                             const gchar *label,
1080                                                             enum sipe_buddy_menu_type type,
1081                                                             gpointer parameter);
1082 struct sipe_backend_buddy_menu *sipe_backend_buddy_menu_separator(struct sipe_core_public *sipe_public,
1083                                                                   struct sipe_backend_buddy_menu *menu,
1084                                                                   const gchar *label);
1085 struct sipe_backend_buddy_menu *sipe_backend_buddy_sub_menu_add(struct sipe_core_public *sipe_public,
1086                                                                 struct sipe_backend_buddy_menu *menu,
1087                                                                 const gchar *label,
1088                                                                 struct sipe_backend_buddy_menu *sub);
1089
1090 SipeEncryptionPolicy sipe_backend_media_get_encryption_policy(struct sipe_core_public *sipe_public);
1091
1092 #ifdef __cplusplus
1093 }
1094 #endif
1095
1096 /*
1097   Local Variables:
1098   mode: c
1099   c-file-style: "bsd"
1100   indent-tabs-mode: t
1101   tab-width: 8
1102   End:
1103 */