icd/srv_provider_api.h

Go to the documentation of this file.

#ifndef SRV_PROVIDER_API_H
#define SRV_PROVIDER_API_H

/*
 This file is part of icd2-dev, ICd2 development header files.

 Copyright (C) 2007-2008 Nokia Corporation. All rights reserved.

 Contact: Patrik Flykt <patrik.flykt@nokia.com>

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice,
    this list of conditions and the following disclaimer.
  * Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.
  * Neither the name of Nokia Corporation nor the names of its contributors
    may be used to endorse or promote products derived from this software
    without specific prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
*/

#ifdef __cplusplus
extern "C" {
#endif

#include <sys/types.h>
#include <unistd.h>
#include <glib.h>

#include <dbus_api.h>
#include <network_api.h>

#define ICD_SRV_MODULE_VERSION ICD_NW_MODULE_VERSION

enum icd_srv_status {
  ICD_SRV_SUCCESS = 0,
  ICD_SRV_RESTART = 1,
  ICD_SRV_ERROR = 2
};

enum icd_srv_identify_status {
  ICD_SRV_UNKNOWN = 0,
  ICD_SRV_IDENTIFIED = 1,
  ICD_SRV_CONTINUE = 8,
};

typedef void
(*icd_srv_identify_cb_fn) (const enum icd_srv_identify_status status,
                           const gchar *service_type,
                           const gchar *service_name,
                           const guint service_attrs,
                           const gchar *service_id,
                           const gint service_priority,
                           const gchar *network_type,
                           const guint network_attrs,
                           const gchar *network_id,
                           gpointer identify_cb_token);
typedef void (*icd_srv_identify_fn) (enum icd_scan_status status,
                                     const gchar *network_type,
                                     const gchar *network_name,
                                     const guint network_attrs,
                                     const gchar *network_id,
                                     const guint network_priority,
                                     enum icd_nw_levels signal,
                                     const gchar *station_id,
                                     const gint dB,
                                     icd_srv_identify_cb_fn identify_cb,
                                     gpointer identify_cb_token,
                                     gpointer *private);

typedef void (*icd_srv_disconnect_cb_fn) (enum icd_srv_status status,
                                          gpointer disconnect_cb_token);
typedef void (*icd_srv_disconnect_fn) (const gchar *service_type,
                                       const guint service_attrs,
                                       const gchar *service_id,
                                       const gchar *network_type,
                                       const guint network_attrs,
                                       const gchar *network_id,
                                       const gchar *interface_name,
                                       icd_srv_disconnect_cb_fn disconnect_cb,
                                       gpointer disconnect_cb_token,
                                       gpointer *private);

typedef void (*icd_srv_connect_cb_fn) (enum icd_srv_status status,
                                       const gchar *err_str,
                                       gpointer connect_cb_token);
typedef void (*icd_srv_connect_fn) (const gchar *service_type,
                                    const guint service_attrs,
                                    const gchar *service_id,
                                    const gchar *network_type,
                                    const guint network_attrs,
                                    const gchar *network_id,
                                    const gchar *interface_name,
                                    icd_srv_connect_cb_fn connect_cb,
                                    gpointer connect_cb_token,
                                    gpointer *private);

typedef void (*icd_srv_child_exit_fn) (const pid_t pid,
                                       const gint exit_status,
                                       gpointer *private);

typedef void (*icd_srv_destruct_fn) (gpointer *private);

struct icd_srv_api {

  const gchar *version;

  gpointer private;

  icd_srv_connect_fn connect;

  icd_srv_disconnect_fn disconnect;

  icd_srv_identify_fn identify;

  icd_srv_child_exit_fn child_exit;

  icd_srv_destruct_fn srv_destruct;
};


typedef void (*icd_srv_watch_pid_fn) (const pid_t pid,
                                      gpointer watch_cb_token);

typedef void (*icd_srv_close_fn) (enum icd_srv_status status,
                                  const gchar *err_str,
                                  const gchar *service_type,
                                  const guint service_attrs,
                                  const gchar *service_id,
                                  const gchar *network_type,
                                  const guint network_attrs,
                                  const gchar *network_id);

enum icd_srv_limited_conn_status {
  ICD_SRV_LIMITED_CONN_DISABLED = 0,
  ICD_SRV_LIMITED_CONN_ENABLED = 1
};
typedef void
(*icd_srv_limited_conn_fn) (const enum icd_srv_limited_conn_status conn_status,
                            const gchar *service_type,
                            const guint service_attrs,
                            const gchar *service_id,
                            const gchar *network_type,
                            const guint network_attrs,
                            const gchar *network_id);

typedef gboolean (*icd_srv_init_fn) (struct icd_srv_api *srv_api,
                                     icd_srv_watch_pid_fn watch_cb,
                                     gpointer watch_cb_token,
                                     icd_srv_close_fn close,
                                     icd_srv_limited_conn_fn limited_conn);

#ifdef __cplusplus
}
#endif

#endif

---