icd/network_api.h

Go to the documentation of this file.

#ifndef NETWORK_API_H
#define NETWORK_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>


#define ICD_NW_MODULE_VERSION  "0.87+fremantle9+0m5"

#include "network_api_defines.h"


typedef void (*icd_nw_layer_renew_cb_fn) (enum icd_nw_renew_status status,
                                          gpointer renew_cb_token);
typedef void (*icd_nw_layer_renew_fn) (const gchar *network_type,
                                       const guint network_attrs,
                                       const gchar *network_id,
                                       icd_nw_layer_renew_cb_fn renew_cb,
                                       gpointer renew_cb_token,
                                       gpointer *private);

typedef void
(*icd_nw_ip_down_cb_fn) (const enum icd_nw_status status,
                         const gpointer ip_down_cb_token);
typedef void
(*icd_nw_ip_down_fn) (const gchar *network_type,
                      const guint network_attrs,
                      const gchar *network_id,
                      const gchar *interface_name,
                      icd_nw_ip_down_cb_fn ip_down_cb,
                      gpointer ip_down_cb_token,
                      gpointer *private);

typedef void (*icd_nw_ip_up_cb_fn) (const enum icd_nw_status status,
                                    const gchar *err_str,
                                    const gpointer ip_up_cb_token,
                                    ...);
typedef void
(*icd_nw_ip_up_fn) (const gchar *network_type,
                    const guint network_attrs,
                    const gchar *network_id,
                    const gchar *interface_name,
                    icd_nw_ip_up_cb_fn ip_up_cb,
                    gpointer ip_up_cb_token,
                    gpointer *private);

typedef void (*icd_nw_ip_addr_info_cb_fn) (const gpointer addr_info_cb_token,
                                           const gchar *network_type,
                                           const guint network_attrs,
                                           const gchar *network_id,
                                           gchar *ip_address,
                                           gchar *ip_netmask,
                                           gchar *ip_gateway,
                                           gchar *ip_dns1,
                                           gchar *ip_dns2,
                                           gchar *ip_dns3);
typedef void (*icd_nw_ip_addr_info_fn) (const gchar *network_type,
                                        const guint network_attrs,
                                        const gchar *network_id,
                                        gpointer *private,
                                        icd_nw_ip_addr_info_cb_fn cb,
                                        const gpointer addr_info_cb_token);

typedef void (*icd_nw_ip_stats_cb_fn) (const gpointer ip_stats_cb_token,
                                       const gchar *network_type,
                                       const guint network_attrs,
                                       const gchar *network_id,
                                       guint time_active,
                                       guint rx_bytes,
                                       guint tx_bytes);

typedef void (*icd_nw_ip_stats_fn) (const gchar *network_type,
                                    const guint network_attrs,
                                    const gchar *network_id,
                                    gpointer *private,
                                    icd_nw_ip_stats_cb_fn cb,
                                    const gpointer ip_stats_cb_token);

typedef void
(*icd_nw_link_pre_down_cb_fn) (const enum icd_nw_status status,
                               const gpointer link_pre_down_cb_token);
typedef void
(*icd_nw_link_pre_down_fn) (const gchar *network_type,
                            const guint network_attrs,
                            const gchar *network_id,
                            const gchar *interface_name,
                            icd_nw_link_pre_down_cb_fn link_pre_down_cb,
                            const gpointer link_pre_down_cb_token,
                            gpointer *private);

typedef void
(*icd_nw_link_post_up_cb_fn) (const enum icd_nw_status status,
                              const gchar *err_str,
                              const gpointer link_post_up_cb_token,
                              ...);
typedef void
(*icd_nw_link_post_up_fn) (const gchar *network_type,
                           const guint network_attrs,
                           const gchar *network_id,
                           const gchar *interface_name,
                           icd_nw_link_post_up_cb_fn link_post_up,
                           const gpointer link_post_up_cb_token,
                           gpointer *private);

typedef void
(*icd_nw_link_post_stats_cb_fn) (const gpointer link_post_stats_cb_token,
                                 const gchar *network_type,
                                 const guint network_attrs,
                                 const gchar *network_id,
                                 guint time_active,
                                 guint rx_bytes,
                                 guint tx_bytes);

typedef void
(*icd_nw_link_post_stats_fn) (const gchar *network_type,
                              const guint network_attrs,
                              const gchar *network_id,
                              gpointer *private,
                              icd_nw_link_post_stats_cb_fn cb,
                              const gpointer link_post_stats_cb_token);

typedef void
(*icd_nw_link_down_cb_fn) (const enum icd_nw_status status,
                           const gpointer link_down_cb_token);
typedef void
(*icd_nw_link_down_fn) (const gchar *network_type,
                        const guint network_attrs,
                        const gchar *network_id,
                        const gchar *interface_name,
                        icd_nw_link_down_cb_fn link_down_cb,
                        const gpointer link_down_cb_token,
                        gpointer *private);

typedef void
(*icd_nw_link_up_cb_fn) (const enum icd_nw_status status,
                         const gchar *err_str,
                         const gchar *interface_name,
                         const gpointer link_up_cb_token,
                         ...);
typedef void
(*icd_nw_link_up_fn) (const gchar *network_type,
                      const guint network_attrs,
                      const gchar *network_id,
                      icd_nw_link_up_cb_fn link_up_cb,
                      const gpointer link_up_cb_token,
                      gpointer *private);

typedef void (*icd_nw_link_stats_cb_fn) (const gpointer link_stats_cb_token,
                                         const gchar *network_type,
                                         const guint network_attrs,
                                         const gchar *network_id,
                                         guint time_active,
                                         gint signal,
                                         gchar *station_id,
                                         gint dB,
                                         guint rx_bytes,
                                         guint tx_bytes);

typedef void (*icd_nw_link_stats_fn) (const gchar *network_type,
                                      const guint network_attrs,
                                      const gchar *network_id,
                                      gpointer *private,
                                      icd_nw_link_stats_cb_fn cb,
                                      const gpointer link_stats_cb_token);

typedef void
(*icd_nw_search_cb_fn) (enum icd_network_search_status status,
                        gchar *network_name,
                        gchar *network_type,
                        const guint network_attrs,
                        gchar *network_id,
                        enum icd_nw_levels signal,
                        gchar *station_id,
                        gint dB,
                        const gpointer search_cb_token);
typedef void
(*icd_nw_start_search_fn) (const gchar *network_type,
                           guint search_scope,
                           icd_nw_search_cb_fn search_cb,
                           const gpointer search_cb_token,
                           gpointer *private);
typedef void
(*icd_nw_stop_search_fn) (gpointer *private);

typedef void
(*icd_nw_child_exit_fn) (const pid_t pid,
                         const gint exit_value,
                         gpointer *private);


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

struct icd_nw_api {
  gchar *version;

  gpointer private;

  icd_nw_ip_down_fn ip_down;
  icd_nw_ip_up_fn ip_up;
  icd_nw_ip_addr_info_fn ip_addr_info;
  icd_nw_ip_stats_fn ip_stats;

  icd_nw_link_pre_down_fn link_pre_down;
  icd_nw_link_post_up_fn link_post_up;
  icd_nw_link_post_stats_fn link_post_stats;

  icd_nw_link_down_fn link_down;
  icd_nw_link_up_fn link_up;
  icd_nw_link_stats_fn link_stats;

  guint search_lifetime;
  guint search_interval;
  icd_nw_start_search_fn start_search;
  icd_nw_stop_search_fn stop_search;

  icd_nw_child_exit_fn child_exit;

  icd_nw_network_destruct_fn network_destruct;

  icd_nw_layer_renew_fn ip_renew;
  icd_nw_layer_renew_fn link_post_renew;
  icd_nw_layer_renew_fn link_renew;
};


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

typedef void (*icd_nw_close_fn) (enum icd_nw_status status,
                                 const gchar *err_str,
                                 const gchar *network_type,
                                 const guint network_attrs,
                                 const gchar *network_id);

typedef void (*icd_nw_status_change_fn) (gchar *network_type,
                                         guint network_attrs,
                                         gchar *network_id);

typedef void (*icd_nw_renew_fn) (enum icd_nw_layer renew_layer,
                                 const gchar *network_type,
                                 const guint network_attrs,
                                 const gchar *network_id);

typedef gboolean
(*icd_nw_init_fn) (struct icd_nw_api *network_api,
                   icd_nw_watch_pid_fn watch_fn,
                   gpointer watch_fn_token,
                   icd_nw_close_fn close_fn,
                   icd_nw_status_change_fn status_change_fn,
                   icd_nw_renew_fn renew_fn);

#ifdef __cplusplus
}
#endif

#endif

---